@cursor/july 0.1.99 → 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 {
@@ -19,14 +14,20 @@ import {
 import { createStreamDeliveryStrategy } from "./live-delivery.js";
 import { defaultSlackLog, type SlackLog } from "./log.js";
 import { createProgressDelivery } from "./progress-delivery.js";
-import { buildTaskChunkForResult, buildTaskChunksForCalls } from "./stream.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 =
@@ -59,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]")
@@ -126,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`.
@@ -147,11 +152,17 @@ 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 });
@@ -160,6 +171,59 @@ export function buildDefaultEvents(
   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,
     threadTs: string
@@ -297,8 +361,11 @@ export function buildDefaultEvents(
       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 = {};
 
@@ -324,16 +391,16 @@ export function buildDefaultEvents(
     },
 
     async "message.appended"(event, channel) {
-      if (!streamLive(channel.state)) {
+      // 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,
@@ -343,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;
@@ -366,113 +445,111 @@ 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 &&
-        streamLive(channel.state)
+        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,
-        });
-        if (
-          thinkingSteps &&
-          channel.state.streamingUnavailable === true &&
-          (channel.state.streamTs === null || channel.state.streamTs === "")
-        ) {
-          await progress.upsert({ channel, text: statusText });
-        }
+        await progress.upsert({ channel, text: statusText });
       }
     },
 
     async "action.result"(event, channel) {
       const streamTs = channel.state.streamTs;
       if (
+        toolCards === null ||
         !strategy.inlineToolSteps ||
-        !thinkingSteps ||
-        !streamLive(channel.state) ||
+        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: 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;
@@ -488,6 +565,8 @@ 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 === "") {
@@ -523,6 +602,7 @@ export function buildDefaultEvents(
         typeof result === "string" &&
         result !== "" &&
         result !== channel.state.lastPostedText;
+      await completeReasoning(channel, event.sessionId);
       if (unpublished) {
         await deliverReplyText({
           channel,
@@ -582,6 +662,7 @@ export function buildDefaultEvents(
 
       let delivered = false;
       if (streamLive(state)) {
+        await completeReasoning(channel, event.sessionId);
         ({ delivered } = await strategy.fail({
           channel,
           channelId: state.streamChannelId ?? state.channelId,

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,
@@ -129,8 +130,11 @@ export function emptySlackChannelState(
     streamBlockText: null,
     lastBotMessageTs: null,
     streamingUnavailable: false,
+    streamFull: false,
     progressTs: null,
     approvalMessageByCallId: {},
+    reasoningCard: undefined,
+    toolCardCounts: {},
     ...patch,
   };
 }
@@ -797,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";