@cursor/july 0.1.95 → 0.1.96

package/src/channels/slack/dispatch.ts

@@ -9,6 +9,7 @@ import {
   normalizeIdentity,
 } from "../../internal/continuation-identity.js";
 import { routeLocalIngressContinuation } from "../../internal/local-ingress.js";
+import { steeringEnabled } from "../../internal/steering.js";
 import type {
   ArtifactsApi,
   HostContext,
@@ -16,7 +17,11 @@ import type {
   SendMessageFn,
 } from "../../types.js";
 import { buildSlackBinding, slackContinuationKey } from "./api.js";
-import { firstLineTitle, maybeSetThreadTitle } from "./assistant.js";
+import {
+  firstLineTitle,
+  maybeSetSuggestedPrompts,
+  maybeSetThreadTitle,
+} from "./assistant.js";
 import {
   appendSlackAttachmentAnnotations,
   prepareSlackAttachments,
@@ -33,6 +38,7 @@ import { isExternalSlackSender } from "./external-policy.js";
 import {
   formatSlackContextBlock,
   parseAppMentionEvent,
+  parseAssistantThreadStarted,
   parseChannelMessageEvent,
   parseDirectMessageEvent,
   parseReactionAddedEvent,
@@ -51,6 +57,7 @@ import type {
   SlackDispatchDecision,
   SlackMessage,
   SlackMessageHandler,
+  SlackSuggestedPrompt,
 } from "./types.js";
 
 const FOLLOWUP_TYPING = "Saw your follow-up…";
@@ -167,6 +174,12 @@ export interface SlackInboundDispatchDeps extends SlackContinuationProbes {
    * `false` to admit them (or when an upstream gate already refused them).
    */
   blockExternals?: boolean;
+  /**
+   * Suggested prompts written on `assistant_thread_started` so the
+   * assistant pane is not blank before the first user message.
+   */
+  suggestedPrompts?: SlackSuggestedPrompt[];
+  suggestedPromptsTitle?: string;
 }
 
 function triggeringMergeMessage(
@@ -529,27 +542,24 @@ export async function dispatchInboundMessage(args: {
         continuation,
         event_id: args.eventId,
       });
-      // Queue it for mid-turn injection too. The carrier drains this at the
-      // running turn's next tool boundary; whatever it does not reach in time
-      // still drains into the boundary turn, deduped by sourceTs.
-      try {
-        await args.host.slackNudges?.append({
-          continuationKey: continuation,
-          sourceTs: message.ts,
-          text: media.userText,
-          ...(message.author?.userName === undefined
-            ? {}
-            : { author: message.author.userName }),
-        });
-      } catch (nudgeError) {
-        log.warn("nudge append failed", {
-          error:
-            nudgeError instanceof Error
-              ? nudgeError.message
-              : String(nudgeError),
-          continuation,
-          event_id: args.eventId,
-        });
+      if (!steeringEnabled()) {
+        try {
+          await args.host.slackNudges?.append({
+            continuationKey: continuation,
+            sourceTs: message.ts,
+            text: media.userText,
+            author: message.author?.userName,
+          });
+        } catch (nudgeError) {
+          log.warn("nudge append failed", {
+            error:
+              nudgeError instanceof Error
+                ? nudgeError.message
+                : String(nudgeError),
+            continuation,
+            event_id: args.eventId,
+          });
+        }
       }
       try {
         if (args.followUpStatus !== false) {
@@ -750,6 +760,30 @@ export function dispatchInboundFromEventBody(
     return true;
   }
 
+  const assistantThread = parseAssistantThreadStarted(body);
+  if (assistantThread !== null) {
+    const prompts = deps.suggestedPrompts ?? [];
+    log.info("assistant thread started", {
+      channel: assistantThread.channelId,
+      thread_ts: assistantThread.threadTs,
+      user: assistantThread.userId,
+      event_id: eventId,
+    });
+    if (prompts.length > 0) {
+      deps.waitUntil(
+        maybeSetSuggestedPrompts({
+          botToken: deps.credentials?.botToken,
+          channelId: assistantThread.channelId,
+          threadTs: assistantThread.threadTs,
+          prompts,
+          title: deps.suggestedPromptsTitle,
+          log,
+        })
+      );
+    }
+    return true;
+  }
+
   if (deps.channelWatch !== undefined) {
     // Parse keeps bot-authored posts; the watcher enforces the per-channel
     // policy (includeBotPosts, own-post loop safety) with skip logging.

package/src/channels/slack/inbound.ts

@@ -121,6 +121,49 @@ export function parseAppMentionEvent(
   return delegation === undefined ? message : { ...message, delegation };
 }
 
+export interface SlackAssistantThreadStarted {
+  channelId: string;
+  threadTs: string;
+  userId?: string;
+  teamId?: string;
+}
+
+/** Slack fires this when a user opens the assistant pane. No model turn. */
+export function parseAssistantThreadStarted(
+  body: unknown
+): SlackAssistantThreadStarted | null {
+  const root = asRecord(body);
+  if (root === null || root.type !== "event_callback") {
+    return null;
+  }
+  const event = asRecord(root.event);
+  if (event === null || event.type !== "assistant_thread_started") {
+    return null;
+  }
+  const thread = asRecord(event.assistant_thread);
+  if (thread === null) {
+    return null;
+  }
+  const channelId = asString(thread.channel_id);
+  const threadTs = asString(thread.thread_ts);
+  if (
+    channelId === undefined ||
+    channelId === "" ||
+    threadTs === undefined ||
+    threadTs === ""
+  ) {
+    return null;
+  }
+  const userId = asString(thread.user_id);
+  const teamId = asString(root.team_id) ?? asString(event.team_id);
+  return {
+    channelId,
+    threadTs,
+    userId: userId === undefined || userId === "" ? undefined : userId,
+    teamId: teamId === undefined || teamId === "" ? undefined : teamId,
+  };
+}
+
 /**
  * Parse DM / IM messages. More generous than a strict channel_type check:
  * accepts `channel_type === "im"` or channel ids starting with `D`, and

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

@@ -4,12 +4,16 @@
  * Cursor-account channels do not use this path — they reply with a single
  * final `chat.postMessage` and put thinking on `assistant.threads.setStatus`
  * (no message edits).
+ *
+ * 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.
  */
 
 import type { ChannelEventContext } from "../../types.js";
 import { appendChatStream, startChatStream, stopChatStream } from "./api.js";
 import type { SlackLog } from "./log.js";
-import { computeStreamAppend } from "./stream.js";
+import { computeStreamAppend, type StreamTaskChunk } from "./stream.js";
 import type { SlackBotToken, SlackChannelState } from "./types.js";
 
 type SlackChannel = ChannelEventContext<SlackChannelState>;
@@ -19,96 +23,195 @@ export interface LiveDeliveryDeps {
   getLog: () => SlackLog;
 }
 
+type OpenArgs = {
+  channel: SlackChannel;
+  channelId: string;
+  threadTs: string;
+  sessionId: string;
+  markdown_text?: string;
+  chunks?: StreamTaskChunk[];
+};
+
+type StreamArgs = {
+  channel: SlackChannel;
+  channelId: string;
+  sessionId: string;
+};
+
 /**
  * How the default handlers deliver an in-progress reply. Methods write live
  * delivery state (`streamTs`, `streamChannelId`, `lastPostedText`,
  * `streamingUnavailable`) on `channel.state` directly.
  */
 export interface LiveDeliveryStrategy {
-  /** True when tool-call thinking steps can be appended to the live message. */
   readonly inlineToolSteps: boolean;
-  /** Open the live message (stream start). */
-  start(args: {
-    channel: SlackChannel;
-    channelId: string;
-    threadTs: string;
-    sessionId: string;
-  }): Promise<void>;
-  /** Push the latest cumulative text to the live message (throttled). */
-  append(args: {
-    channel: SlackChannel;
-    channelId: string;
-    streamTs: string;
-    text: string;
-    sessionId: string;
-  }): Promise<void>;
+  /** Open the live message with the first real markdown or task chunks. */
+  open(args: OpenArgs): Promise<boolean>;
+  append(args: StreamArgs & { text: string }): Promise<void>;
+  appendChunks(
+    args: StreamArgs & { chunks: StreamTaskChunk[] }
+  ): Promise<boolean>;
   /**
    * Flush the final reply text. `delivered` is false only when the caller must
    * post the full reply as a fresh message (finalize failed on partial text).
    */
-  finalize(args: {
-    channel: SlackChannel;
-    channelId: string;
-    streamTs: string;
-    text: string;
-    sessionId: string;
-  }): Promise<{ delivered: boolean }>;
-  /** Close the live message when the turn produced no final text. */
-  finalizeEmpty(args: {
-    channel: SlackChannel;
-    channelId: string;
-    streamTs: string;
-  }): Promise<void>;
-  /** Best-effort remove a live message left open after the turn ended. */
+  finalize(
+    args: StreamArgs & { text: string }
+  ): Promise<{ delivered: boolean }>;
+  finalizeEmpty(args: { channel: SlackChannel }): Promise<void>;
   cleanupOrphan(args: { channel: SlackChannel }): Promise<void>;
-  /** Deliver the error text into the live message; `delivered` gates a fallback post. */
-  fail(args: {
-    channel: SlackChannel;
-    channelId: string;
-    streamTs: string;
-    errorText: string;
-    sessionId: string;
-  }): Promise<{ delivered: boolean }>;
+  fail(
+    args: StreamArgs & { errorText: string }
+  ): Promise<{ delivered: boolean }>;
+}
+
+function streamRecipients(channel: SlackChannel): {
+  recipient_user_id: string | undefined;
+  recipient_team_id: string | undefined;
+} {
+  const user = channel.state.triggeringUserId;
+  const team = channel.state.teamId;
+  return {
+    recipient_user_id: user === null || user === "" ? undefined : user,
+    recipient_team_id: team === null || team === "" ? undefined : team,
+  };
+}
+
+function activeStreamTs(channel: SlackChannel): string | null {
+  const ts = channel.state.streamTs;
+  return ts === null || ts === "" ? null : ts;
 }
 
 export function createStreamDeliveryStrategy(
   deps: LiveDeliveryDeps
 ): LiveDeliveryStrategy {
   const { botToken, getLog } = deps;
-  return {
-    inlineToolSteps: true,
 
-    async start({ channel, channelId, threadTs, sessionId }) {
-      const log = getLog();
-      const started = await startChatStream({
-        botToken,
+  const open: LiveDeliveryStrategy["open"] = async ({
+    channel,
+    channelId,
+    threadTs,
+    sessionId,
+    markdown_text,
+    chunks,
+  }) => {
+    if (activeStreamTs(channel) !== null) {
+      return true;
+    }
+    const hasMarkdown = markdown_text !== undefined && markdown_text !== "";
+    const hasChunks = chunks !== undefined && chunks.length > 0;
+    if (!hasMarkdown && !hasChunks) {
+      return false;
+    }
+    const log = getLog();
+    const started = await startChatStream({
+      botToken,
+      channel: channelId,
+      thread_ts: threadTs,
+      markdown_text: hasMarkdown ? markdown_text : undefined,
+      chunks: hasChunks ? chunks : undefined,
+      ...streamRecipients(channel),
+    });
+    if (!started.ok) {
+      log.warn("chat.startStream unavailable", {
+        error: started.error,
         channel: channelId,
         thread_ts: threadTs,
-        markdown_text: "",
-      });
-      if (!started.ok) {
-        log.warn("chat.startStream unavailable", {
-          error: started.error,
-          channel: channelId,
-          thread_ts: threadTs,
-          session: sessionId,
-        });
-        if (started.unsupported === true) {
-          channel.state.streamingUnavailable = true;
-        }
-        return;
-      }
-      channel.state.streamTs = started.ts;
-      channel.state.streamChannelId = started.channel;
-      channel.state.lastPostedText = "";
-      log.info("chat.startStream ok", {
-        channel: started.channel,
-        stream_ts: started.ts,
         session: sessionId,
       });
-    },
+      if (started.unsupported === true) {
+        channel.state.streamingUnavailable = true;
+      }
+      return false;
+    }
+    channel.state.streamTs = started.ts;
+    channel.state.streamChannelId = started.channel;
+    channel.state.lastPostedText = hasMarkdown ? (markdown_text ?? "") : "";
+    log.info("chat.startStream ok", {
+      channel: started.channel,
+      stream_ts: started.ts,
+      session: sessionId,
+    });
+    return true;
+  };
+
+  const ensureOpen = async (
+    args: StreamArgs & {
+      markdown_text?: string;
+      chunks?: StreamTaskChunk[];
+    }
+  ): Promise<string | null> => {
+    const existing = activeStreamTs(args.channel);
+    if (existing !== null) {
+      return existing;
+    }
+    const threadTs = args.channel.state.threadTs;
+    if (threadTs === null || threadTs === "") {
+      return null;
+    }
+    const opened = await open({
+      channel: args.channel,
+      channelId: args.channelId,
+      threadTs,
+      sessionId: args.sessionId,
+      markdown_text: args.markdown_text,
+      chunks: args.chunks,
+    });
+    return opened ? activeStreamTs(args.channel) : null;
+  };
+
+  const stopWithSuffix = async (args: {
+    channel: SlackChannel;
+    channelId: string;
+    ts: string;
+    text: string;
+  }): Promise<{ ok: boolean; error?: string }> => {
+    const appendText = computeStreamAppend(
+      args.channel.state.lastPostedText,
+      args.text
+    );
+    const stopped = await stopChatStream({
+      botToken,
+      channel: args.channelId,
+      ts: args.ts,
+      markdown_text: appendText === "" ? undefined : appendText,
+    });
+    args.channel.state.streamTs = null;
+    if (stopped.ok) {
+      args.channel.state.lastPostedText = args.text;
+      args.channel.state.lastBotMessageTs = args.ts;
+      return { ok: true };
+    }
+    if (stopped.unsupported === true) {
+      args.channel.state.streamingUnavailable = true;
+    }
+    return { ok: false, error: stopped.error };
+  };
 
-    async append({ channel, channelId, streamTs, text, sessionId }) {
+  const closeOrphan = async (channel: SlackChannel): Promise<void> => {
+    const orphanTs = activeStreamTs(channel);
+    const channelId = channel.state.streamChannelId ?? channel.state.channelId;
+    if (orphanTs === null || channelId === null || channelId === "") {
+      return;
+    }
+    await stopChatStream({ botToken, channel: channelId, ts: orphanTs });
+    channel.state.streamTs = null;
+  };
+
+  return {
+    inlineToolSteps: true,
+    open,
+
+    async append({ channel, channelId, text, sessionId }) {
+      const ts = await ensureOpen({
+        channel,
+        channelId,
+        sessionId,
+        markdown_text: text,
+      });
+      if (ts === null) {
+        return;
+      }
       const appendText = computeStreamAppend(
         channel.state.lastPostedText,
         text
@@ -119,14 +222,14 @@ export function createStreamDeliveryStrategy(
       const result = await appendChatStream({
         botToken,
         channel: channelId,
-        ts: streamTs,
+        ts,
         markdown_text: appendText,
       });
       if (!result.ok) {
         getLog().warn("appendStream failed", {
           error: result.error,
           channel: channelId,
-          stream_ts: streamTs,
+          stream_ts: ts,
           session: sessionId,
         });
         if (result.unsupported === true) {
@@ -137,26 +240,50 @@ export function createStreamDeliveryStrategy(
       channel.state.lastPostedText = text;
     },
 
-    async finalize({ channel, channelId, streamTs, text, sessionId }) {
-      const log = getLog();
-      // Only send the unsent suffix — full text was already appended.
-      const appendText = computeStreamAppend(
-        channel.state.lastPostedText,
-        text
-      );
-      const stopped = await stopChatStream({
+    async appendChunks({ channel, channelId, chunks, sessionId }) {
+      const hadStream = activeStreamTs(channel) !== null;
+      const ts = await ensureOpen({
+        channel,
+        channelId,
+        sessionId,
+        chunks,
+      });
+      if (ts === null) {
+        return false;
+      }
+      if (!hadStream) {
+        return true;
+      }
+      const result = await appendChatStream({
         botToken,
         channel: channelId,
-        ts: streamTs,
-        markdown_text: appendText === "" ? undefined : appendText,
+        ts,
+        chunks,
+      });
+      return result.ok;
+    },
+
+    async finalize({ channel, channelId, text, sessionId }) {
+      const log = getLog();
+      const ts = await ensureOpen({
+        channel,
+        channelId,
+        sessionId,
+        markdown_text: text,
+      });
+      if (ts === null) {
+        return { delivered: false };
+      }
+      const stopped = await stopWithSuffix({
+        channel,
+        channelId,
+        ts,
+        text,
       });
       if (stopped.ok) {
-        channel.state.streamTs = null;
-        channel.state.lastPostedText = text;
-        channel.state.lastBotMessageTs = streamTs;
         log.info("reply delivered via stream", {
           channel: channelId,
-          stream_ts: streamTs,
+          stream_ts: ts,
           session: sessionId,
           chars: text.length,
         });
@@ -165,52 +292,46 @@ export function createStreamDeliveryStrategy(
       log.warn("chat.stopStream failed; falling back to postMessage", {
         error: stopped.error,
         channel: channelId,
-        stream_ts: streamTs,
+        stream_ts: ts,
         session: sessionId,
       });
-      if (stopped.unsupported === true) {
-        channel.state.streamingUnavailable = true;
-      }
-      channel.state.streamTs = null;
-      // If we already streamed content, do not post the full reply again.
       const alreadyStreamed =
         typeof channel.state.lastPostedText === "string" &&
         channel.state.lastPostedText.length > 0;
       return { delivered: alreadyStreamed };
     },
 
-    async finalizeEmpty({ channelId, streamTs }) {
-      await stopChatStream({ botToken, channel: channelId, ts: streamTs });
+    async finalizeEmpty({ channel }) {
+      await closeOrphan(channel);
     },
 
     async cleanupOrphan({ channel }) {
-      // message.completed / turn.failed already stop the stream. If the
-      // turn ended without a final assistant message, close it here so
-      // Slack does not leave the live reply in a streaming state.
-      const streamTs = channel.state.streamTs;
-      const channelId =
-        channel.state.streamChannelId ?? channel.state.channelId;
-      if (
-        streamTs === null ||
-        streamTs === "" ||
-        channelId === null ||
-        channelId === ""
-      ) {
-        return;
-      }
-      await stopChatStream({ botToken, channel: channelId, ts: streamTs });
-      channel.state.streamTs = null;
+      await closeOrphan(channel);
     },
 
-    async fail({ channel, channelId, streamTs, errorText }) {
-      const stopped = await stopChatStream({
-        botToken,
-        channel: channelId,
-        ts: streamTs,
+    async fail({ channel, channelId, errorText, sessionId }) {
+      const ts = await ensureOpen({
+        channel,
+        channelId,
+        sessionId,
         markdown_text: errorText,
       });
-      channel.state.streamTs = null;
-      return { delivered: stopped.ok };
+      if (ts === null) {
+        return { delivered: false };
+      }
+      const stopped = await stopWithSuffix({
+        channel,
+        channelId,
+        ts,
+        text: errorText,
+      });
+      if (stopped.ok) {
+        return { delivered: true };
+      }
+      const alreadyStreamed =
+        typeof channel.state.lastPostedText === "string" &&
+        channel.state.lastPostedText.length > 0;
+      return { delivered: alreadyStreamed };
     },
   };
 }

package/src/channels/slack/manifest.ts

@@ -81,7 +81,11 @@ const BOT_SCOPES = [
   "users:read",
 ] as const;
 
-const BOT_EVENTS = ["app_mention", "message.im"] as const;
+const BOT_EVENTS = [
+  "app_mention",
+  "message.im",
+  "assistant_thread_started",
+] as const;
 
 /** Slack's display_information.description bound. */
 const MAX_DESCRIPTION_LENGTH = 140;