@cursor/july 0.1.97 → 0.1.100

package/src/channels/slack/defaults.ts

@@ -3,12 +3,7 @@
  */
 
 import type { ChannelEventContext, ChannelEventHandlers } from "../../types.js";
-import {
-  appendChatStream,
-  postMessage,
-  setThreadStatus,
-  truncateTypingStatus,
-} from "./api.js";
+import { postMessage, setThreadStatus, truncateTypingStatus } from "./api.js";
 import { firstNonEmptyLine, maybeSetSuggestedPrompts } from "./assistant.js";
 import { defaultSlackAuth } from "./auth.js";
 import {
@@ -18,14 +13,21 @@ import {
 } from "./constants.js";
 import { createStreamDeliveryStrategy } from "./live-delivery.js";
 import { defaultSlackLog, type SlackLog } from "./log.js";
-import { buildTaskChunkForResult, buildTaskChunksForCalls } from "./stream.js";
+import { createProgressDelivery } from "./progress-delivery.js";
+import { createReasoningCard, type ReasoningCard } from "./reasoning-card.js";
+import { redactSecretTokens } from "./redact.js";
+import { resolveSlackReply } from "./reply-options.js";
+import type { StreamTaskChunk } from "./stream.js";
+import { createToolCards, type ToolCards } from "./tool-cards.js";
 import type {
   SlackAccessPolicy,
   SlackChannelState,
   SlackCredentials,
   SlackMessageHandler,
+  SlackReplyOptions,
   SlackRespondTo,
   SlackSuggestedPrompt,
+  SlackToolLabels,
 } from "./types.js";
 
 const SLACK_TURN_FAILURE_FALLBACK =
@@ -58,9 +60,8 @@ export function formatSlackTurnFailureMessage(raw: string | undefined): string {
 }
 
 function scrubSlackErrorDetail(message: string): string {
-  const scrubbed = message
+  const scrubbed = redactSecretTokens(message)
     .replace(/https?:\/\/\S+/gi, "[url]")
-    .replace(/\b(crsr_|xox[baprs]-|sk-|Bearer\s+)\S+/gi, "[redacted]")
     .replace(/\/(?:home|Users|var\/folders)\/\S+/g, "[path]")
     .replace(/\b[A-Za-z]:(?:\\|\/)[^\s]+/g, "[path]")
     .replace(/\\\\[^\s]+/g, "[path]")
@@ -125,19 +126,24 @@ export const defaultOnChannelPost: SlackMessageHandler =
 
 export interface BuildDefaultEventsOptions {
   credentials?: SlackCredentials;
+  /** Same shape as `slackChannel({ reply })`; see {@link SlackReplyOptions}. */
+  reply?: SlackReplyOptions;
+  /** Same as `slackChannel({ toolLabels })`. */
+  toolLabels?: SlackToolLabels;
+  /** @deprecated Use `reply`. */
   streaming?: boolean;
+  /** @deprecated Use `reply`. */
   thinkingSteps?: boolean;
+  /** @deprecated Use `reply.status.idle`. */
+  loadingMessages?: readonly string[];
   suggestedPrompts?: SlackSuggestedPrompt[];
   suggestedPromptsTitle?: string;
-  /** Rotating assistant status lines; defaults to pack constants. */
-  loadingMessages?: readonly string[];
   /** Resolved per-call so channel onStart can rebind the server logger. */
   getLog?: () => SlackLog;
 }
 
 /**
  * Build default stream-event handlers (typing, streaming, replies).
- * Streaming / thinking default to ON.
  *
  * Tool-approval cards are a separate primitive — compose with
  * `buildToolApprovalEvents` or set `toolApprovals: true` on `slackChannel`.
@@ -146,14 +152,77 @@ export function buildDefaultEvents(
   options: BuildDefaultEventsOptions = {}
 ): ChannelEventHandlers<SlackChannelState> {
   const credentials = options.credentials;
-  const streaming = options.streaming !== false;
-  const thinkingSteps = options.thinkingSteps !== false;
+  const reply = resolveSlackReply({
+    reply: options.reply,
+    toolLabels: options.toolLabels,
+    streaming: options.streaming,
+    thinkingSteps: options.thinkingSteps,
+    loadingMessages: options.loadingMessages,
+  });
+  const streaming = reply.mode === "stream";
   const suggestedPrompts = options.suggestedPrompts ?? [];
   const suggestedPromptsTitle = options.suggestedPromptsTitle;
-  const loadingMessages = resolveLoadingMessages(options.loadingMessages);
+  const loadingMessages = reply.status.idle;
   const botToken = credentials?.botToken;
   const getLog = options.getLog ?? (() => defaultSlackLog);
   const strategy = createStreamDeliveryStrategy({ botToken, getLog });
+  const progress = createProgressDelivery({ botToken, getLog });
+
+  const streamLive = (state: SlackChannelState): boolean =>
+    streaming && !state.streamingUnavailable;
+
+  const streamTarget = (
+    channel: ChannelEventContext<SlackChannelState>
+  ): string | null => {
+    const channelId = channel.state.streamChannelId ?? channel.state.channelId;
+    if (
+      channelId === null ||
+      channelId === "" ||
+      channel.state.threadTs === null
+    ) {
+      return null;
+    }
+    return channelId;
+  };
+
+  const sendCards = async (args: {
+    channel: ChannelEventContext<SlackChannelState>;
+    sessionId: string;
+    chunks: StreamTaskChunk[];
+  }): Promise<boolean> => {
+    if (!streamLive(args.channel.state)) {
+      return false;
+    }
+    const channelId = streamTarget(args.channel);
+    if (channelId === null) {
+      return false;
+    }
+    return strategy.appendChunks({ ...args, channelId });
+  };
+
+  const reasoning: ReasoningCard | null =
+    reply.reasoningCard === false
+      ? null
+      : createReasoningCard(reply.reasoningCard, ({ chunk, ...rest }) =>
+          sendCards({ ...rest, chunks: [chunk] })
+        );
+  const toolCards: ToolCards | null =
+    reply.toolCards === false
+      ? null
+      : createToolCards(reply.toolCards, reply.toolLabel);
+
+  const completeReasoning = async (
+    channel: ChannelEventContext<SlackChannelState>,
+    sessionId: string
+  ): Promise<void> => {
+    if (reasoning?.inProgress(channel)) {
+      await reasoning.flush({ channel, sessionId, status: "complete" });
+    }
+  };
+
+  /** Subagent events carry `parentCallId`; cards and the reply are the parent's. */
+  const nested = (event: { data: { parentCallId?: string } }): boolean =>
+    event.data.parentCallId !== undefined;
 
   const clearWorkingStatus = async (
     channelId: string,
@@ -174,6 +243,62 @@ export function buildDefaultEvents(
     }
   };
 
+  const finishProgress = async (args: {
+    channel: ChannelEventContext<SlackChannelState>;
+    text: string;
+    sessionId: string;
+  }): Promise<boolean> => {
+    const log = getLog();
+    const state = args.channel.state;
+    if (
+      state.channelId === null ||
+      state.threadTs === null ||
+      args.text === ""
+    ) {
+      return false;
+    }
+    if (await progress.replace({ channel: args.channel, text: args.text })) {
+      log.info("reply delivered via progress update", {
+        channel: state.channelId,
+        thread_ts: state.threadTs,
+        session: args.sessionId,
+        chars: args.text.length,
+      });
+      return true;
+    }
+    await progress.clear({ channel: args.channel });
+    try {
+      const posted = await postMessage({
+        botToken,
+        channel: state.channelId,
+        text: args.text,
+        threadTs: state.threadTs,
+      });
+      state.lastPostedText = args.text;
+      state.lastBotMessageTs = posted.ts;
+      log.info("reply delivered via postMessage", {
+        channel: state.channelId,
+        thread_ts: state.threadTs,
+        message_ts: posted.ts,
+        session: args.sessionId,
+        chars: args.text.length,
+      });
+      return true;
+    } catch (error) {
+      log.error(
+        `postMessage failed: ${
+          error instanceof Error ? error.message : String(error)
+        }`,
+        {
+          channel: state.channelId,
+          thread_ts: state.threadTs,
+          session: args.sessionId,
+        }
+      );
+      return false;
+    }
+  };
+
   /**
    * Deliver assistant text to the bound Slack thread. Used by a stop-reason
    * `message.completed` and by `turn.completed` when the last assistant
@@ -185,7 +310,6 @@ export function buildDefaultEvents(
     text: string;
     sessionId: string;
   }): Promise<boolean> => {
-    const log = getLog();
     const state = args.channel.state;
     if (
       state.channelId === null ||
@@ -199,8 +323,7 @@ export function buildDefaultEvents(
       // pending. Treat a match as "already on Slack", not "already finalized".
       const streamTs = state.streamTs;
       if (streamTs !== null && streamTs !== "") {
-        const canStream = streaming && state.streamingUnavailable !== true;
-        if (canStream) {
+        if (streamLive(state)) {
           await strategy.finalize({
             channel: args.channel,
             channelId: state.streamChannelId ?? state.channelId,
@@ -214,8 +337,7 @@ export function buildDefaultEvents(
       return true;
     }
 
-    const canStream = streaming && state.streamingUnavailable !== true;
-    if (canStream) {
+    if (streamLive(state)) {
       const { delivered } = await strategy.finalize({
         channel: args.channel,
         channelId: state.streamChannelId ?? state.channelId,
@@ -227,47 +349,23 @@ export function buildDefaultEvents(
       }
     }
 
-    try {
-      const posted = await postMessage({
-        botToken,
-        channel: state.channelId,
-        text: args.text,
-        threadTs: state.threadTs,
-      });
-      state.lastPostedText = args.text;
-      state.lastBotMessageTs = posted.ts;
-      log.info("reply delivered via postMessage", {
-        channel: state.channelId,
-        thread_ts: state.threadTs,
-        message_ts: posted.ts,
-        session: args.sessionId,
-        chars: args.text.length,
-      });
-      return true;
-    } catch (error) {
-      log.error(
-        `postMessage failed: ${
-          error instanceof Error ? error.message : String(error)
-        }`,
-        {
-          channel: state.channelId,
-          thread_ts: state.threadTs,
-          session: args.sessionId,
-        }
-      );
-      return false;
-    }
+    return finishProgress(args);
   };
 
   return {
     async "turn.started"(event, channel) {
       const log = getLog();
+      await progress.clear({ channel });
       channel.state.pendingToolCallMessage = null;
       channel.state.lastReasoningTypingAtMs = null;
       channel.state.lastReasoningTypingStatus = null;
       channel.state.streamTs = null;
       channel.state.streamChannelId = null;
+      channel.state.streamFull = false;
       channel.state.lastPostedText = null;
+      channel.state.streamBlockText = null;
+      channel.state.reasoningCard = undefined;
+      channel.state.toolCardCounts = {};
       // Keep lastBotMessageTs across turns — warm delta watermark.
       channel.state.approvalMessageByCallId = {};
 
@@ -293,16 +391,16 @@ export function buildDefaultEvents(
     },
 
     async "message.appended"(event, channel) {
-      if (!streaming || channel.state.streamingUnavailable === true) {
+      // Nested (subagent) text is not the reply.
+      if (nested(event) || !streamLive(channel.state)) {
         return;
       }
-      const channelId =
-        channel.state.streamChannelId ?? channel.state.channelId;
-      const threadTs = channel.state.threadTs;
-      if (channelId === null || channelId === "" || threadTs === null) {
+      const channelId = streamTarget(channel);
+      if (channelId === null) {
         return;
       }
 
+      await completeReasoning(channel, event.sessionId);
       await strategy.append({
         channel,
         channelId,
@@ -312,6 +410,18 @@ export function buildDefaultEvents(
     },
 
     async "reasoning.appended"(event, channel) {
+      if (!nested(event)) {
+        await reasoning?.append({
+          channel,
+          sessionId: event.sessionId,
+          text: event.data.text,
+        });
+      }
+
+      // The chip is hidden while a stream is open.
+      if (!reply.status.reasoning || channel.state.streamTs !== null) {
+        return;
+      }
       const line = firstNonEmptyLine(event.data.text);
       if (line === undefined) {
         return;
@@ -335,110 +445,117 @@ export function buildDefaultEvents(
       if (channel.state.channelId === null || channel.state.threadTs === null) {
         return;
       }
+      // One entry: Slack cycles `loading_messages` every couple of seconds,
+      // so padding an informative line with the rotation makes the chip
+      // flip between the reasoning and filler until the next update.
       await setThreadStatus({
         botToken,
         channelId: channel.state.channelId,
         threadTs: channel.state.threadTs,
         status,
-        loadingMessages: [
-          status,
-          ...loadingMessages.filter((message) => message !== status),
-        ],
+        loadingMessages: [status],
       });
       channel.state.lastReasoningTypingAtMs = now;
       channel.state.lastReasoningTypingStatus = status;
     },
 
+    async "reasoning.completed"(event, channel) {
+      if (reasoning === null || nested(event)) {
+        return;
+      }
+      reasoning.endBlock(channel);
+      await reasoning.flush({
+        channel,
+        sessionId: event.sessionId,
+        status: "in_progress",
+      });
+    },
+
     async "actions.requested"(event, channel) {
       const pending = channel.state.pendingToolCallMessage;
       channel.state.pendingToolCallMessage = null;
-      const names = event.data.calls.map((call) => call.toolName);
+      const calls = event.data.calls;
+
+      if (toolCards !== null && strategy.inlineToolSteps && !nested(event)) {
+        // Card order: the thinking that led to these tools goes first.
+        await reasoning?.flush({
+          channel,
+          sessionId: event.sessionId,
+          status: "in_progress",
+        });
+        const streamed = await sendCards({
+          channel,
+          sessionId: event.sessionId,
+          chunks: toolCards.forCalls(channel.state, calls),
+        });
+        // An open stream hides the chip; skip the status write.
+        if (streamed) {
+          return;
+        }
+      }
 
+      if (reply.status.tools === false) {
+        return;
+      }
       const statusText =
         pending !== null
           ? truncateTypingStatus(pending)
-          : truncateTypingStatus(`Running ${names.join(", ")}…`);
-
+          : truncateTypingStatus(reply.status.tools(calls));
+      if (channel.state.channelId === null || channel.state.threadTs === null) {
+        return;
+      }
+      // Hold the tool line steady; see reasoning.appended.
+      await setThreadStatus({
+        botToken,
+        channelId: channel.state.channelId,
+        threadTs: channel.state.threadTs,
+        status: statusText,
+        loadingMessages: [statusText],
+      });
       if (
-        strategy.inlineToolSteps &&
-        thinkingSteps &&
-        streaming &&
-        channel.state.streamingUnavailable !== true
+        toolCards !== null &&
+        channel.state.streamingUnavailable === true &&
+        (channel.state.streamTs === null || channel.state.streamTs === "")
       ) {
-        const channelId =
-          channel.state.streamChannelId ?? channel.state.channelId;
-        const threadTs = channel.state.threadTs;
-        if (channelId !== null && channelId !== "" && threadTs !== null) {
-          const chunks = buildTaskChunksForCalls(
-            event.data.calls,
-            "in_progress"
-          );
-          const streamed = await strategy.appendChunks({
-            channel,
-            channelId,
-            chunks,
-            sessionId: event.sessionId,
-          });
-          if (streamed) {
-            if (
-              channel.state.channelId !== null &&
-              channel.state.threadTs !== null
-            ) {
-              await setThreadStatus({
-                botToken,
-                channelId: channel.state.channelId,
-                threadTs: channel.state.threadTs,
-                status: statusText,
-              });
-            }
-            return;
-          }
-        }
-      }
-
-      if (channel.state.channelId !== null && channel.state.threadTs !== null) {
-        await setThreadStatus({
-          botToken,
-          channelId: channel.state.channelId,
-          threadTs: channel.state.threadTs,
-          status: statusText,
-        });
+        await progress.upsert({ channel, text: statusText });
       }
     },
 
     async "action.result"(event, channel) {
+      const streamTs = channel.state.streamTs;
       if (
+        toolCards === null ||
         !strategy.inlineToolSteps ||
-        !thinkingSteps ||
-        !streaming ||
-        channel.state.streamingUnavailable === true ||
-        channel.state.streamTs === null ||
-        channel.state.streamTs === ""
+        nested(event) ||
+        streamTs === null ||
+        streamTs === ""
       ) {
         return;
       }
-      const channelId =
-        channel.state.streamChannelId ?? channel.state.channelId;
-      if (channelId === null || channelId === "") {
-        return;
-      }
-      const chunk = buildTaskChunkForResult({
-        callId: event.data.callId,
-        toolName: event.data.toolName,
-        isError: event.data.isError,
-      });
-      await appendChatStream({
-        botToken,
-        channel: channelId,
-        ts: channel.state.streamTs,
-        chunks: [chunk],
+      await sendCards({
+        channel,
+        sessionId: event.sessionId,
+        chunks: [
+          toolCards.forResult(channel.state, {
+            callId: event.data.callId,
+            toolName: event.data.toolName,
+            output: event.data.output,
+            isError: event.data.isError,
+          }),
+        ],
       });
     },
 
     async "message.completed"(event, channel) {
+      if (nested(event)) {
+        return;
+      }
       if (event.data.finishReason === "tool_call") {
         channel.state.pendingToolCallMessage =
           firstNonEmptyLine(event.data.text) ?? null;
+        // The harness restarts its cumulative text after a tool call, so the
+        // next block appends in full instead of diffing against this one.
+        channel.state.streamBlockText = null;
         return;
       }
       channel.state.pendingToolCallMessage = null;
@@ -448,10 +565,13 @@ export function buildDefaultEvents(
         return;
       }
 
+      await completeReasoning(channel, event.sessionId);
+
       // Empty final text: still close any open stream / clear the skeleton
       // and clear typing.
       if (event.data.text === "") {
         await strategy.finalizeEmpty({ channel });
+        await progress.clear({ channel });
         await clearWorkingStatus(state.channelId, state.threadTs);
         return;
       }
@@ -482,6 +602,7 @@ export function buildDefaultEvents(
         typeof result === "string" &&
         result !== "" &&
         result !== channel.state.lastPostedText;
+      await completeReasoning(channel, event.sessionId);
       if (unpublished) {
         await deliverReplyText({
           channel,
@@ -492,6 +613,7 @@ export function buildDefaultEvents(
       // Always close leftovers. deliverReplyText may fall through to
       // postMessage when streaming is unavailable and leave streamTs open.
       await strategy.cleanupOrphan({ channel });
+      await progress.clear({ channel });
 
       // Always drop the assistant chip. message.completed already clears
       // after a normal reply, but a tool-call-only finish (or a missed
@@ -539,7 +661,8 @@ export function buildDefaultEvents(
       const errorText = formatSlackTurnFailureMessage(event.data.message);
 
       let delivered = false;
-      if (streaming && state.streamingUnavailable !== true) {
+      if (streamLive(state)) {
+        await completeReasoning(channel, event.sessionId);
         ({ delivered } = await strategy.fail({
           channel,
           channelId: state.streamChannelId ?? state.channelId,
@@ -548,25 +671,11 @@ export function buildDefaultEvents(
         }));
       }
       if (!delivered) {
-        try {
-          await postMessage({
-            botToken,
-            channel: state.channelId,
-            text: errorText,
-            threadTs: state.threadTs,
-          });
-        } catch (error) {
-          log.error(
-            `turn.failed postMessage failed: ${
-              error instanceof Error ? error.message : String(error)
-            }`,
-            {
-              channel: state.channelId,
-              thread_ts: state.threadTs,
-              session: event.sessionId,
-            }
-          );
-        }
+        await finishProgress({
+          channel,
+          text: errorText,
+          sessionId: event.sessionId,
+        });
       }
       await clearWorkingStatus(state.channelId, state.threadTs);
     },

package/src/channels/slack/dispatch.ts

@@ -36,6 +36,7 @@ import {
 import type { EventIdDedupe } from "./event-id-dedupe.js";
 import { isExternalSlackSender } from "./external-policy.js";
 import {
+  describeSlackEventShape,
   formatSlackContextBlock,
   parseAppMentionEvent,
   parseAssistantThreadStarted,
@@ -126,9 +127,14 @@ export function emptySlackChannelState(
     streamTs: null,
     streamChannelId: null,
     lastPostedText: null,
+    streamBlockText: null,
     lastBotMessageTs: null,
     streamingUnavailable: false,
+    streamFull: false,
+    progressTs: null,
     approvalMessageByCallId: {},
+    reasoningCard: undefined,
+    toolCardCounts: {},
     ...patch,
   };
 }
@@ -795,6 +801,9 @@ export function dispatchInboundFromEventBody(
     }
   }
 
-  log.debug("inbound ignored (unhandled event shape)", { event_id: eventId });
+  log.debug("inbound ignored (unhandled event shape)", {
+    ...describeSlackEventShape(body),
+    event_id: eventId,
+  });
   return false;
 }

package/src/channels/slack/inbound.ts

@@ -20,6 +20,23 @@ function asString(value: unknown): string | undefined {
   return typeof value === "string" ? value : undefined;
 }
 
+/**
+ * `type` / `subtype` of an Events API body's inner event, for log lines about
+ * payloads no parser claimed (own-bot echoes, `message_changed`, pane
+ * context changes). Never throws on odd shapes.
+ */
+export function describeSlackEventShape(body: unknown): {
+  event_type: string;
+  event_subtype?: string;
+} {
+  const root = asRecord(body);
+  const event = asRecord(root?.event);
+  return {
+    event_type: asString(event?.type) ?? asString(root?.type) ?? "unknown",
+    event_subtype: asString(event?.subtype),
+  };
+}
+
 /** Strip common Slack mention tokens for a cleaner model prompt. */
 export function slackTextToMarkdown(text: string): string {
   return text

package/src/channels/slack/index.ts

@@ -46,4 +46,5 @@ export * from "./stop.js";
 export * from "./stream.js";
 export * from "./thread-context.js";
 export * from "./tool-approval-events.js";
+export { defaultToolCardDetails } from "./tool-cards.js";
 export * from "./types.js";