@cursor/july 0.1.109 → 0.1.111

package/src/channels/slack/defaults.ts

@@ -2,23 +2,27 @@
  * Default inbound handlers and stream-event sinks for the Slack channel.
  */
 
+import {
+  markHostedFirstVisibleReply,
+  noteHostedVisibleReplyError,
+} from "../../internal/hosted-execution-latency.js";
 import type { ChannelEventContext, ChannelEventHandlers } from "../../types.js";
-import { postMessage, setThreadStatus, truncateTypingStatus } from "./api.js";
-import { firstNonEmptyLine, maybeSetSuggestedPrompts } from "./assistant.js";
+import { buildAgenticEvents } from "./agentic-delivery.js";
+import { postMessage, setThreadStatus } from "./api.js";
+import { maybeSetSuggestedPrompts } from "./assistant.js";
 import { defaultSlackAuth } from "./auth.js";
-import {
-  SLACK_DEFAULT_LOADING_MESSAGES,
-  SLACK_TYPING_MIN_GROWTH,
-  SLACK_TYPING_MIN_INTERVAL_MS,
-} from "./constants.js";
+import { SLACK_DEFAULT_LOADING_MESSAGES } from "./constants.js";
+import { paintSlackFooter, turnDurationMs } from "./footer.js";
 import { createStreamDeliveryStrategy } from "./live-delivery.js";
 import { defaultSlackLog, type SlackLog } from "./log.js";
 import { createProgressDelivery } from "./progress-delivery.js";
 import { createReasoningCard, type ReasoningCard } from "./reasoning-card.js";
+import { commitReasoningChip, nextReasoningChip } from "./reasoning-chip.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 { rememberPendingToolCall, takeToolChipLine } from "./tool-chip.js";
 import type {
   SlackAccessPolicy,
   SlackChannelState,
@@ -59,6 +63,14 @@ export function formatSlackTurnFailureMessage(raw: string | undefined): string {
   return `I hit an error while handling your request: ${scrubbed}`;
 }
 
+function streamHasCards(state: SlackChannelState): boolean {
+  if (state.reasoningCard !== undefined) {
+    return true;
+  }
+  const counts = state.toolCardCounts;
+  return counts !== undefined && Object.keys(counts).length > 0;
+}
+
 function scrubSlackErrorDetail(message: string): string {
   const scrubbed = redactSecretTokens(message)
     .replace(/https?:\/\/\S+/gi, "[url]")
@@ -145,6 +157,9 @@ export interface BuildDefaultEventsOptions {
 /**
  * Build default stream-event handlers (typing, streaming, replies).
  *
+ * `reply.mode: "agentic"` installs the communication-tool watcher
+ * instead of the post/stream sinks.
+ *
  * Tool-approval cards are a separate primitive — compose with
  * `buildToolApprovalEvents` or set `toolApprovals: true` on `slackChannel`.
  */
@@ -159,6 +174,16 @@ export function buildDefaultEvents(
     thinkingSteps: options.thinkingSteps,
     loadingMessages: options.loadingMessages,
   });
+  if (reply.mode === "agentic") {
+    return buildAgenticEvents({
+      credentials,
+      getLog: options.getLog,
+      ack: reply.ack,
+      placeholder: reply.placeholder,
+      status: reply.status,
+      footer: reply.footer,
+    });
+  }
   const streaming = reply.mode === "stream";
   const suggestedPrompts = options.suggestedPrompts ?? [];
   const suggestedPromptsTitle = options.suggestedPromptsTitle;
@@ -264,6 +289,10 @@ export function buildDefaultEvents(
         session: args.sessionId,
         chars: args.text.length,
       });
+      markHostedFirstVisibleReply({
+        outcome: "progress_update",
+        deliverySurface: "slack",
+      });
       return true;
     }
     await progress.clear({ channel: args.channel });
@@ -283,6 +312,10 @@ export function buildDefaultEvents(
         session: args.sessionId,
         chars: args.text.length,
       });
+      markHostedFirstVisibleReply({
+        outcome: "final_post",
+        deliverySurface: "slack",
+      });
       return true;
     } catch (error) {
       log.error(
@@ -295,6 +328,7 @@ export function buildDefaultEvents(
           session: args.sessionId,
         }
       );
+      noteHostedVisibleReplyError({ deliverySurface: "slack" });
       return false;
     }
   };
@@ -352,6 +386,46 @@ export function buildDefaultEvents(
     return finishProgress(args);
   };
 
+  const paintReplyFooter = async (args: {
+    channel: ChannelEventContext<SlackChannelState>;
+    sessionId: string;
+    status: "completed" | "failed";
+  }): Promise<void> => {
+    const state = args.channel.state;
+    const ts = state.lastBotMessageTs;
+    const text = state.lastPostedText;
+    if (
+      ts == null ||
+      ts === "" ||
+      text == null ||
+      text === "" ||
+      state.channelId === null ||
+      state.threadTs === null ||
+      streamHasCards(state)
+    ) {
+      return;
+    }
+    const result = await paintSlackFooter({
+      footer: reply.footer,
+      ctx: {
+        sessionId: args.sessionId,
+        channelId: state.channelId,
+        threadTs: state.threadTs,
+        text,
+        status: args.status,
+        durationMs: turnDurationMs(state.turnStartedAtMs),
+      },
+      ts,
+      botToken,
+    });
+    if (result !== undefined && !result.ok) {
+      getLog().warn(`reply footer failed: ${result.error}`, {
+        channel: state.channelId,
+        ts,
+      });
+    }
+  };
+
   return {
     async "turn.started"(event, channel) {
       const log = getLog();
@@ -367,6 +441,7 @@ export function buildDefaultEvents(
       channel.state.streamAppendedChunks = 0;
       channel.state.lastPostedText = null;
       channel.state.streamBlockText = null;
+      channel.state.turnStartedAtMs = Date.now();
       channel.state.reasoningCard = undefined;
       channel.state.toolCardCounts = {};
       // Keep lastBotMessageTs across turns — warm delta watermark.
@@ -425,24 +500,9 @@ export function buildDefaultEvents(
       if (!reply.status.reasoning || channel.state.streamTs !== null) {
         return;
       }
-      const line = firstNonEmptyLine(event.data.text);
-      if (line === undefined) {
-        return;
-      }
-      const status = truncateTypingStatus(line);
-      const previous = channel.state.lastReasoningTypingStatus;
-      const grew =
-        previous !== null &&
-        status.startsWith(previous) &&
-        status.length >= previous.length + SLACK_TYPING_MIN_GROWTH;
       const now = Date.now();
-      const lastAt = channel.state.lastReasoningTypingAtMs;
-      if (
-        !grew &&
-        lastAt !== null &&
-        now - lastAt >= 0 &&
-        now - lastAt < SLACK_TYPING_MIN_INTERVAL_MS
-      ) {
+      const status = nextReasoningChip(channel.state, event.data.text, now);
+      if (status === undefined) {
         return;
       }
       if (channel.state.channelId === null || channel.state.threadTs === null) {
@@ -451,15 +511,16 @@ export function buildDefaultEvents(
       // 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({
+      const painted = await setThreadStatus({
         botToken,
         channelId: channel.state.channelId,
         threadTs: channel.state.threadTs,
         status,
         loadingMessages: [status],
       });
-      channel.state.lastReasoningTypingAtMs = now;
-      channel.state.lastReasoningTypingStatus = status;
+      if (painted.ok) {
+        commitReasoningChip(channel.state, status, now);
+      }
     },
 
     async "reasoning.completed"(event, channel) {
@@ -475,9 +536,12 @@ export function buildDefaultEvents(
     },
 
     async "actions.requested"(event, channel) {
-      const pending = channel.state.pendingToolCallMessage;
-      channel.state.pendingToolCallMessage = null;
       const calls = event.data.calls;
+      const statusText = takeToolChipLine(
+        channel.state,
+        reply.status.tools,
+        calls
+      );
 
       if (toolCards !== null && strategy.inlineToolSteps && !nested(event)) {
         // Card order: the thinking that led to these tools goes first.
@@ -497,13 +561,9 @@ export function buildDefaultEvents(
         }
       }
 
-      if (reply.status.tools === false) {
+      if (statusText === undefined) {
         return;
       }
-      const statusText =
-        pending !== null
-          ? truncateTypingStatus(pending)
-          : truncateTypingStatus(reply.status.tools(calls));
       if (channel.state.channelId === null || channel.state.threadTs === null) {
         return;
       }
@@ -553,15 +613,17 @@ export function buildDefaultEvents(
       if (nested(event)) {
         return;
       }
+      rememberPendingToolCall(
+        channel.state,
+        event.data.finishReason,
+        event.data.text
+      );
       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;
 
       const state = channel.state;
       if (state.channelId === null || state.threadTs === null) {
@@ -617,6 +679,11 @@ export function buildDefaultEvents(
       // postMessage when streaming is unavailable and leave streamTs open.
       await strategy.cleanupOrphan({ channel });
       await progress.clear({ channel });
+      await paintReplyFooter({
+        channel,
+        sessionId: event.sessionId,
+        status: "completed",
+      });
 
       // Always drop the assistant chip. message.completed already clears
       // after a normal reply, but a tool-call-only finish (or a missed
@@ -680,6 +747,11 @@ export function buildDefaultEvents(
           sessionId: event.sessionId,
         });
       }
+      await paintReplyFooter({
+        channel,
+        sessionId: event.sessionId,
+        status: "failed",
+      });
       await clearWorkingStatus(state.channelId, state.threadTs);
     },
   };