@cursor/july 0.1.108 → 0.1.111

package/src/channels/origin/defaults.ts

@@ -99,7 +99,11 @@ export function buildDefaultOriginEvents(
       if (!deliverReplies) {
         return;
       }
-      if (event.data.finishReason === "tool_call" || event.data.text === "") {
+      if (
+        event.data.parentCallId !== undefined ||
+        event.data.finishReason === "tool_call" ||
+        event.data.text === ""
+      ) {
         return;
       }
       try {

package/src/channels/origin/events.ts

@@ -26,7 +26,7 @@ export function deriveOriginWebhookEvents(
   if (options.webhookEvents !== undefined) {
     return [
       ...new Set(
-        options.webhookEvents.map((event) => event.trim()).filter(Boolean)
+        options.webhookEvents.map(event => event.trim()).filter(Boolean)
       ),
     ];
   }

package/src/channels/origin/origin-channel.ts

@@ -142,7 +142,7 @@ function shouldSkipOriginVerify(): boolean {
 function asIdList(value: string | readonly string[] | undefined): string[] {
   if (value === undefined) return [];
   const items = typeof value === "string" ? [value] : [...value];
-  return [...new Set(items.map((id) => id.trim()).filter(Boolean))];
+  return [...new Set(items.map(id => id.trim()).filter(Boolean))];
 }
 
 /** `AGENT_SERVE_ORIGIN_APP_ID` fallback for {@link OriginChannelOptions.appId}. */
@@ -454,6 +454,7 @@ function enrichEventContext(input: {
     origin: buildOriginBinding({
       repository: input.ctx.repository,
       installationId: input.ctx.installationId,
+      executionId: input.ctx.deliveryId,
       cursorAccount:
         input.options.cursorAccount !== undefined &&
         input.options.cursorAccount !== false,

package/src/channels/origin/origin-webhook.ts

@@ -98,8 +98,8 @@ export function verifyV1edWebhookPayload(args: {
   );
   const candidateSignatures = signatureHeader
     .split(/\s+/)
-    .filter((entry) => entry.startsWith(`${V1ED_SIGNATURE_VERSION},`))
-    .map((entry) => entry.slice(V1ED_SIGNATURE_VERSION.length + 1))
+    .filter(entry => entry.startsWith(`${V1ED_SIGNATURE_VERSION},`))
+    .map(entry => entry.slice(V1ED_SIGNATURE_VERSION.length + 1))
     .slice(0, MAX_V1ED_CANDIDATE_SIGNATURES);
   if (candidateSignatures.length === 0) {
     return false;

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

@@ -0,0 +1,659 @@
+/**
+ * Agentic Slack watches communication tools on the turn stream and
+ * renders them through the channel Slack client. The tools do not call
+ * Slack. Writes happen on a successful, non-stubbed `action.result`.
+ *
+ * Ack and the thinking chip are channel-owned: they fire on `turn.started`
+ * / `reasoning.appended` / `actions.requested`, not from model `react` /
+ * `set-status`. Prefer the last assistant line before a `tool_call`.
+ */
+
+import {
+  markHostedFirstVisibleReply,
+  noteHostedVisibleReplyError,
+} from "../../internal/hosted-execution-latency.js";
+import type { ChannelEventContext, ChannelEventHandlers } from "../../types.js";
+import {
+  begin,
+  bind,
+  end,
+  has,
+  latest,
+  latestPosted,
+  remove,
+  resolve,
+  setPostedText,
+} from "./agentic-posted.js";
+import {
+  DELETE_MESSAGE,
+  EDIT_MESSAGE,
+  isOwnedSignal,
+  isSignal,
+  POST_CARD,
+  POST_FILE,
+  POST_UPDATE,
+  parseCard,
+  parseDelete,
+  parseEdit,
+  parseReaction,
+  parseStagedFile,
+  parseUpdate,
+  REACT,
+} from "./agentic-signals.js";
+import {
+  addReaction,
+  deleteMessage,
+  postMessage,
+  setThreadStatus,
+  updateMessage,
+} from "./api.js";
+import {
+  paintSlackFooter,
+  type SlackReplyFooter,
+  turnDurationMs,
+} from "./footer.js";
+import { createStreamDeliveryStrategy } from "./live-delivery.js";
+import { defaultSlackLog, type SlackLog } from "./log.js";
+import { paintTurnStart } from "./paint-start.js";
+import {
+  finishPlaceholder,
+  overlayPlaceholder,
+  startPlaceholder,
+} from "./placeholder.js";
+import { commitReasoningChip, nextReasoningChip } from "./reasoning-chip.js";
+import { DEFAULT_ACK, type ResolvedSlackStatus } from "./reply-options.js";
+import { rememberPendingToolCall, takeToolChipLine } from "./tool-chip.js";
+import type {
+  SlackBotToken,
+  SlackChannelState,
+  SlackCredentials,
+  SoftSlackResult,
+} from "./types.js";
+import { type ThreadFile, uploadThreadFiles } from "./upload.js";
+
+type SlackChannel = ChannelEventContext<SlackChannelState>;
+
+type AgenticWrite = {
+  channel: SlackChannel;
+  output: unknown;
+  sessionId: string;
+  botToken: SlackBotToken | undefined;
+  getLog: () => SlackLog;
+};
+
+function nested(event: { data: { parentCallId?: string } }): boolean {
+  return event.data.parentCallId !== undefined;
+}
+
+function skip(
+  event: { data: { parentCallId?: string } },
+  dryRun: boolean | undefined
+): boolean {
+  return nested(event) || dryRun === true;
+}
+
+function thread(
+  state: SlackChannelState
+): { channelId: string; threadTs: string } | undefined {
+  if (state.channelId === null || state.channelId === "") {
+    return undefined;
+  }
+  if (state.threadTs === null || state.threadTs === "") {
+    return undefined;
+  }
+  return { channelId: state.channelId, threadTs: state.threadTs };
+}
+
+async function postStaticPlaceholder(args: {
+  channel: SlackChannel;
+  placeholder: string | undefined;
+  botToken: SlackBotToken | undefined;
+  log: SlackLog;
+}): Promise<void> {
+  if (args.channel.state.placeholderPosted === true) {
+    return;
+  }
+  if (args.placeholder === undefined) {
+    return;
+  }
+  const target = thread(args.channel.state);
+  if (target === undefined) {
+    return;
+  }
+  const started = startPlaceholder({
+    line: args.placeholder,
+    botToken: args.botToken,
+    channelId: target.channelId,
+    threadTs: target.threadTs,
+    log: args.log,
+    recipientUserId: args.channel.state.triggeringUserId,
+    recipientTeamId: args.channel.state.teamId,
+  });
+  await started?.done;
+}
+
+async function setChip(
+  channel: SlackChannel,
+  status: string,
+  botToken: SlackBotToken | undefined,
+  getLog: () => SlackLog,
+  loadingMessages?: readonly string[]
+): Promise<boolean> {
+  const target = thread(channel.state);
+  if (target === undefined) {
+    return false;
+  }
+  const result = await setThreadStatus({
+    botToken,
+    channelId: target.channelId,
+    threadTs: target.threadTs,
+    status,
+    loadingMessages:
+      loadingMessages === undefined ? undefined : [...loadingMessages],
+  });
+  if (!result.ok) {
+    getLog().warn(`agentic status failed: ${result.error}`, {
+      channel: target.channelId,
+      thread_ts: target.threadTs,
+    });
+    return false;
+  }
+  return true;
+}
+
+async function postNew(args: {
+  channel: SlackChannel;
+  text: string;
+  ts?: string;
+  sessionId: string;
+  botToken: SlackBotToken | undefined;
+  getLog: () => SlackLog;
+}): Promise<void> {
+  const state = args.channel.state;
+  const target = thread(state);
+  if (target === undefined) {
+    return;
+  }
+  const log = args.getLog();
+  const overlaid = await overlayPlaceholder({
+    channelId: target.channelId,
+    threadTs: target.threadTs,
+    botToken: args.botToken,
+    text: args.text,
+  });
+  if (overlaid !== undefined) {
+    state.lastPostedText = args.text;
+    state.lastBotMessageTs = overlaid;
+    bind(args.sessionId, args.ts ?? overlaid, overlaid, args.text);
+    log.info("placeholder replaced", {
+      channel: target.channelId,
+      thread_ts: target.threadTs,
+      message_ts: overlaid,
+      session: args.sessionId,
+      chars: args.text.length,
+    });
+    markHostedFirstVisibleReply({
+      outcome: "progress_update",
+      deliverySurface: "slack",
+    });
+    return;
+  }
+  try {
+    const posted = await postMessage({
+      botToken: args.botToken,
+      channel: target.channelId,
+      text: args.text,
+      threadTs: target.threadTs,
+    });
+    state.lastPostedText = args.text;
+    state.lastBotMessageTs = posted.ts;
+    bind(args.sessionId, args.ts ?? posted.ts, posted.ts, args.text);
+    log.info("agentic reply posted", {
+      channel: target.channelId,
+      thread_ts: target.threadTs,
+      message_ts: posted.ts,
+      session: args.sessionId,
+      chars: args.text.length,
+    });
+    markHostedFirstVisibleReply({
+      outcome: "final_post",
+      deliverySurface: "slack",
+    });
+  } catch (error) {
+    log.warn(
+      `agentic reply failed: ${
+        error instanceof Error ? error.message : String(error)
+      }`,
+      {
+        channel: target.channelId,
+        thread_ts: target.threadTs,
+      }
+    );
+    noteHostedVisibleReplyError({ deliverySurface: "slack" });
+  }
+}
+
+export function buildAgenticEvents(options: {
+  credentials?: SlackCredentials;
+  getLog?: () => SlackLog;
+  ack?: string;
+  placeholder?: string;
+  status: ResolvedSlackStatus;
+  footer?: SlackReplyFooter;
+}): ChannelEventHandlers<SlackChannelState> {
+  const botToken = options.credentials?.botToken;
+  const getLog = options.getLog ?? (() => defaultSlackLog);
+  const ack = options.ack ?? DEFAULT_ACK;
+  const placeholder = options.placeholder;
+  const status = options.status;
+  const stream = createStreamDeliveryStrategy({ botToken, getLog });
+
+  return {
+    async "turn.started"(event, channel, ctx) {
+      await stream.cleanupOrphan({ channel });
+      channel.state.agenticFiles = [];
+      channel.state.streamTs = null;
+      channel.state.streamChannelId = null;
+      channel.state.streamFull = false;
+      channel.state.streamingUnavailable = false;
+      channel.state.streamAppendedChunks = 0;
+      channel.state.lastReasoningTypingAtMs = null;
+      channel.state.lastReasoningTypingStatus = null;
+      channel.state.pendingToolCallMessage = null;
+      channel.state.turnStartedAtMs = Date.now();
+      begin(event.sessionId);
+      if (ctx.session.dryRun === true) {
+        return;
+      }
+      const target = thread(channel.state);
+      if (target === undefined) {
+        return;
+      }
+      if (channel.state.startPainted !== true) {
+        await paintTurnStart({
+          botToken,
+          channelId: target.channelId,
+          threadTs: target.threadTs,
+          ack,
+          log: getLog(),
+        });
+      }
+      await postStaticPlaceholder({
+        channel,
+        placeholder,
+        botToken,
+        log: getLog(),
+      });
+    },
+
+    async "message.received"(_event, channel, ctx) {
+      if (ctx.session.dryRun === true) {
+        return;
+      }
+      await postStaticPlaceholder({
+        channel,
+        placeholder,
+        botToken,
+        log: getLog(),
+      });
+    },
+
+    async "reasoning.appended"(event, channel, ctx) {
+      if (nested(event) || ctx.session.dryRun === true) {
+        return;
+      }
+      if (status.reasoning === false) {
+        return;
+      }
+      const now = Date.now();
+      const line = nextReasoningChip(channel.state, event.data.text, now);
+      if (line === undefined) {
+        return;
+      }
+      if (await setChip(channel, line, botToken, getLog, [line])) {
+        commitReasoningChip(channel.state, line, now);
+      }
+    },
+
+    async "message.completed"(event, channel, ctx) {
+      if (nested(event) || ctx.session.dryRun === true) {
+        return;
+      }
+      rememberPendingToolCall(
+        channel.state,
+        event.data.finishReason,
+        event.data.text
+      );
+    },
+
+    async "actions.requested"(event, channel, ctx) {
+      if (skip(event, ctx.session.dryRun)) {
+        return;
+      }
+      const calls = event.data.calls.filter(
+        call => !isOwnedSignal(call.toolName)
+      );
+      const line = takeToolChipLine(channel.state, status.tools, calls);
+      if (line === undefined) {
+        return;
+      }
+      await setChip(channel, line, botToken, getLog, [line]);
+    },
+
+    async "action.result"(event, channel, ctx) {
+      if (skip(event, ctx.session.dryRun)) {
+        return;
+      }
+      if (event.data.isError || event.data.stubbed === true) {
+        return;
+      }
+      if (isSignal(event.data.toolName, POST_UPDATE)) {
+        const update = parseUpdate(event.data.output);
+        if (update === undefined) {
+          return;
+        }
+        await postNew({
+          channel,
+          text: update.message,
+          ts: update.ts,
+          sessionId: ctx.session.id,
+          botToken,
+          getLog,
+        });
+        return;
+      }
+      if (isSignal(event.data.toolName, EDIT_MESSAGE)) {
+        await applyEdit({
+          channel,
+          output: event.data.output,
+          sessionId: ctx.session.id,
+          botToken,
+          getLog,
+        });
+        return;
+      }
+      if (isSignal(event.data.toolName, DELETE_MESSAGE)) {
+        await applyDelete({
+          channel,
+          output: event.data.output,
+          sessionId: ctx.session.id,
+          botToken,
+          getLog,
+        });
+        return;
+      }
+      if (isSignal(event.data.toolName, POST_CARD)) {
+        const card = parseCard(event.data.output);
+        const channelId = channel.state.channelId;
+        if (card === undefined || channelId === null || channelId === "") {
+          return;
+        }
+        await stream.appendChunks({
+          channel,
+          channelId,
+          sessionId: ctx.session.id,
+          chunks: [
+            {
+              type: "task_update",
+              id: card.id,
+              title: card.title,
+              status: card.status,
+              details: card.details,
+            },
+          ],
+        });
+        return;
+      }
+      if (isSignal(event.data.toolName, REACT)) {
+        await applyReaction({
+          channel,
+          output: event.data.output,
+          sessionId: ctx.session.id,
+          botToken,
+          getLog,
+        });
+        return;
+      }
+      if (!isSignal(event.data.toolName, POST_FILE)) {
+        return;
+      }
+      const file = parseStagedFile(event.data.output);
+      if (file === undefined) {
+        return;
+      }
+      const staged = channel.state.agenticFiles ?? [];
+      staged.push(file);
+      channel.state.agenticFiles = staged;
+    },
+
+    async "turn.completed"(_event, channel, ctx) {
+      await stream.cleanupOrphan({ channel });
+      if (ctx.session.dryRun !== true) {
+        await setChip(channel, "", botToken, getLog);
+        await paintFooter({
+          channel,
+          sessionId: ctx.session.id,
+          status: "completed",
+          footer: options.footer,
+          botToken,
+          getLog,
+        });
+      }
+      await retractUnclaimed(channel, botToken, getLog);
+      end(ctx.session.id);
+      const files = channel.state.agenticFiles ?? [];
+      channel.state.agenticFiles = [];
+      await uploadStaged(files, channel, botToken, getLog);
+    },
+
+    async "turn.failed"(_event, channel, ctx) {
+      await stream.cleanupOrphan({ channel });
+      channel.state.agenticFiles = [];
+      if (ctx.session.dryRun !== true) {
+        await setChip(channel, "", botToken, getLog);
+        await paintFooter({
+          channel,
+          sessionId: ctx.session.id,
+          status: "failed",
+          footer: options.footer,
+          botToken,
+          getLog,
+        });
+      }
+      await retractUnclaimed(channel, botToken, getLog);
+      end(ctx.session.id);
+    },
+  };
+}
+
+async function paintFooter(args: {
+  channel: SlackChannel;
+  sessionId: string;
+  status: "completed" | "failed";
+  footer: SlackReplyFooter | undefined;
+  botToken: SlackBotToken | undefined;
+  getLog: () => SlackLog;
+}): Promise<void> {
+  const posted = latestPosted(args.sessionId);
+  const target = thread(args.channel.state);
+  if (posted === undefined || target === undefined) {
+    return;
+  }
+  const result = await paintSlackFooter({
+    footer: args.footer,
+    ctx: {
+      sessionId: args.sessionId,
+      channelId: target.channelId,
+      threadTs: target.threadTs,
+      text: posted.text,
+      status: args.status,
+      durationMs: turnDurationMs(args.channel.state.turnStartedAtMs),
+    },
+    ts: posted.ts,
+    botToken: args.botToken,
+  });
+  if (result !== undefined && !result.ok) {
+    args.getLog().warn(`agentic footer failed: ${result.error}`, {
+      channel: target.channelId,
+      ts: posted.ts,
+    });
+  }
+}
+
+async function retractUnclaimed(
+  channel: SlackChannel,
+  botToken: SlackBotToken | undefined,
+  getLog: () => SlackLog
+): Promise<void> {
+  const target = thread(channel.state);
+  if (target === undefined) {
+    return;
+  }
+  await finishPlaceholder({
+    channelId: target.channelId,
+    threadTs: target.threadTs,
+    botToken,
+    log: getLog(),
+  });
+}
+
+async function applyOwned(args: {
+  channel: SlackChannel;
+  sessionId: string;
+  ts: string;
+  botToken: SlackBotToken | undefined;
+  getLog: () => SlackLog;
+  verb: "edit" | "delete";
+  write: (channelId: string, ts: string) => Promise<SoftSlackResult>;
+  ok?: (ts: string) => void;
+}): Promise<void> {
+  const target = thread(args.channel.state);
+  if (target === undefined) {
+    return;
+  }
+  const log = args.getLog();
+  if (!has(args.sessionId, args.ts)) {
+    log.warn(
+      `agentic ${args.verb} rejected: ts is not a message this turn posted`,
+      { channel: target.channelId, ts: args.ts }
+    );
+    return;
+  }
+  const slackTs = resolve(args.sessionId, args.ts);
+  if (slackTs === undefined) {
+    return;
+  }
+  const result = await args.write(target.channelId, slackTs);
+  if (!result.ok) {
+    log.warn(`agentic ${args.verb} failed: ${result.error}`, {
+      channel: target.channelId,
+      ts: args.ts,
+    });
+    return;
+  }
+  if (args.ok !== undefined) {
+    args.ok(slackTs);
+  }
+}
+
+async function applyEdit(args: AgenticWrite): Promise<void> {
+  const edit = parseEdit(args.output);
+  if (edit === undefined) {
+    return;
+  }
+  await applyOwned({
+    channel: args.channel,
+    sessionId: args.sessionId,
+    ts: edit.ts,
+    botToken: args.botToken,
+    getLog: args.getLog,
+    verb: "edit",
+    write: (channelId, ts) =>
+      updateMessage({
+        botToken: args.botToken,
+        channel: channelId,
+        ts,
+        text: edit.message,
+      }),
+    ok: slackTs => {
+      setPostedText(args.sessionId, slackTs, edit.message);
+    },
+  });
+}
+
+async function applyDelete(args: AgenticWrite): Promise<void> {
+  const removed = parseDelete(args.output);
+  if (removed === undefined) {
+    return;
+  }
+  await applyOwned({
+    channel: args.channel,
+    sessionId: args.sessionId,
+    ts: removed.ts,
+    botToken: args.botToken,
+    getLog: args.getLog,
+    verb: "delete",
+    write: (channelId, ts) =>
+      deleteMessage({
+        botToken: args.botToken,
+        channel: channelId,
+        ts,
+      }),
+    ok: slackTs => {
+      remove(args.sessionId, removed.ts);
+      if (args.channel.state.lastBotMessageTs === slackTs) {
+        args.channel.state.lastBotMessageTs = latest(args.sessionId) ?? null;
+      }
+    },
+  });
+}
+
+async function applyReaction(args: AgenticWrite): Promise<void> {
+  const reaction = parseReaction(args.output);
+  const target = thread(args.channel.state);
+  if (reaction === undefined || target === undefined) {
+    return;
+  }
+  const ts = reaction.ts ?? target.threadTs;
+  const result = await addReaction({
+    botToken: args.botToken,
+    channel: target.channelId,
+    ts,
+    name: reaction.emoji,
+  });
+  if (!result.ok) {
+    args.getLog().warn(`agentic react failed: ${result.error}`, {
+      channel: target.channelId,
+      ts,
+    });
+  }
+}
+
+async function uploadStaged(
+  files: readonly ThreadFile[],
+  channel: SlackChannel,
+  botToken: SlackBotToken | undefined,
+  getLog: () => SlackLog
+): Promise<void> {
+  if (files.length === 0) {
+    return;
+  }
+  const target = thread(channel.state);
+  if (target === undefined) {
+    return;
+  }
+  const failures = await uploadThreadFiles({
+    botToken,
+    channelId: target.channelId,
+    threadTs: target.threadTs,
+    files,
+  });
+  if (failures.length === 0) {
+    return;
+  }
+  getLog().warn("agentic file upload failed", {
+    channel: target.channelId,
+    thread_ts: target.threadTs,
+    failures: failures.join("; "),
+  });
+}