@vellumai/assistant 0.11.4 → 0.11.5-staging.1

package/src/runtime/routes/inbound-stages/background-dispatch.ts

@@ -8,6 +8,7 @@
  * focused on orchestration.
  */
 import type { AssistantEvent } from "../../../api/index.js";
+import { resolveGuardianPromptDelivery } from "../../../approvals/guardian-channel-delivery.js";
 import {
   extractMessageTsFromCallbackUrl,
   extractThreadTsFromCallbackUrl,
@@ -20,6 +21,12 @@ import {
 } from "../../../contacts/guardian-delivery-reader.js";
 import { isConversationBusyError } from "../../../daemon/conversation-messaging.js";
 import type { TrustContext } from "../../../daemon/trust-context-types.js";
+import {
+  sendChannelReaction,
+  sendChannelTyping,
+  setChannelThreadStatus,
+  supportsChannelTyping,
+} from "../../../messaging/providers/index.js";
 import {
   getSiblingStreamedReplyTs,
   linkMessage,
@@ -161,25 +168,15 @@ export function processChannelMessageInBackground(
   // `channel-turn-admission.ts` for why channel turns defer rather than route
   // through the SSE-oriented conversation queue.
   void withChannelTurnAdmission(conversationId, async () => {
-    const typingCallbackUrl = shouldEmitTelegramTyping(
-      sourceChannel,
-      replyCallbackUrl,
-    )
-      ? replyCallbackUrl
-      : undefined;
-    const stopTypingHeartbeat = typingCallbackUrl
-      ? startTelegramTypingHeartbeat(
-          typingCallbackUrl,
-          externalChatId,
-          assistantId,
-        )
-      : undefined;
+    const stopTypingHeartbeat =
+      replyCallbackUrl && supportsChannelTyping(replyCallbackUrl)
+        ? startTypingHeartbeat(replyCallbackUrl, externalChatId)
+        : undefined;
 
     const slackThinkingStatus = createSlackThinkingStatusController({
       sourceChannel,
       replyCallbackUrl,
       chatId: externalChatId,
-      assistantId,
       startImmediately: shouldStartSlackThinkingStatusImmediately({
         sourceChannel,
         chatType,
@@ -193,6 +190,7 @@ export function processChannelMessageInBackground(
           externalChatId,
           trustClass: trustCtx.trustClass,
           guardianExternalUserId: trustCtx.guardianExternalUserId,
+          guardianChatId: trustCtx.guardianChatId,
           requesterExternalUserId: trustCtx.requesterExternalUserId,
           replyCallbackUrl,
           assistantId,
@@ -230,7 +228,6 @@ export function processChannelMessageInBackground(
         chatType,
         replyCallbackUrl,
         chatId: externalChatId,
-        assistantId,
         recipientUserId: slackInbound?.actorExternalUserId,
         recipientTeamId: slackInbound?.actorTeamId,
         // Durably record the streamed message `ts` the instant the stream
@@ -387,40 +384,23 @@ export function processChannelMessageInBackground(
 // ---------------------------------------------------------------------------
 
 /**
- * How often the typing status is re-sent while a turn runs.
+ * How often the working indicator is re-sent while a turn runs.
  *
- * `sendChatAction` sets a status that expires on its own after a few seconds,
- * and the Bot API offers no stop/start pair to hold one open, so showing
- * typing across a multi-second turn means re-sending on a timer. The interval
- * has to stay under that expiry or the indicator blinks off between beats;
- * anyone changing it should check the current window first.
+ * Every channel that has one expires it after a few seconds and offers no
+ * start/stop pair to hold it open, so showing it across a multi-second turn
+ * means re-sending on a timer. The interval has to stay under the shortest
+ * expiry of any channel that implements `typing`: Telegram is about five
+ * seconds, Discord about ten. Anyone changing it should check the current
+ * windows first.
  *
- * No explicit stop is needed on the delivery path: Telegram clears the status
- * as soon as the bot sends a message.
+ * No explicit stop is needed: both clear the indicator when the bot posts.
  *
  * https://core.telegram.org/bots/api#sendchataction
+ * https://discord.com/developers/docs/resources/channel#trigger-typing-indicator
  */
-const TELEGRAM_TYPING_INTERVAL_MS = 4_000;
-
-function shouldEmitTelegramTyping(
-  sourceChannel: ChannelId,
-  replyCallbackUrl?: string,
-): boolean {
-  if (sourceChannel !== "telegram" || !replyCallbackUrl) {
-    return false;
-  }
-  try {
-    return new URL(replyCallbackUrl).pathname.endsWith("/deliver/telegram");
-  } catch {
-    return replyCallbackUrl.endsWith("/deliver/telegram");
-  }
-}
+const TYPING_INTERVAL_MS = 4_000;
 
-function startTelegramTypingHeartbeat(
-  callbackUrl: string,
-  chatId: string,
-  assistantId?: string,
-): () => void {
+function startTypingHeartbeat(callbackUrl: string, chatId: string): () => void {
   let active = true;
   let inFlight = false;
 
@@ -429,11 +409,7 @@ function startTelegramTypingHeartbeat(
       return;
     }
     inFlight = true;
-    void deliverChannelReply(callbackUrl, {
-      chatId,
-      chatAction: "typing",
-      assistantId,
-    })
+    void sendChannelTyping(callbackUrl, chatId)
       .catch((err) => {
         log.debug(
           { err, chatId },
@@ -447,7 +423,7 @@ function startTelegramTypingHeartbeat(
 
   emitTyping();
 
-  const interval = setInterval(emitTyping, TELEGRAM_TYPING_INTERVAL_MS);
+  const interval = setInterval(emitTyping, TYPING_INTERVAL_MS);
   (interval as { unref?: () => void }).unref?.();
 
   return () => {
@@ -498,16 +474,9 @@ function createSlackThinkingStatusController(params: {
   sourceChannel: ChannelId;
   replyCallbackUrl?: string;
   chatId: string;
-  assistantId?: string;
   startImmediately?: boolean;
 }): SlackThinkingStatusController | undefined {
-  const {
-    sourceChannel,
-    replyCallbackUrl,
-    chatId,
-    assistantId,
-    startImmediately,
-  } = params;
+  const { sourceChannel, replyCallbackUrl, chatId, startImmediately } = params;
   if (
     !replyCallbackUrl ||
     !shouldEmitSlackThinkingStatus(sourceChannel, replyCallbackUrl)
@@ -532,7 +501,6 @@ function createSlackThinkingStatusController(params: {
     slackThinkingStatus = setSlackThinkingStatus(
       callbackUrl,
       chatId,
-      assistantId,
       currentLoadingMessages,
     );
     lastSentLoadingMessageKey = getLoadingMessagesKey(currentLoadingMessages);
@@ -649,7 +617,6 @@ function getTaskProgressLoadingMessage(
 function setSlackThinkingStatus(
   callbackUrl: string,
   chatId: string,
-  assistantId?: string,
   loadingMessages?: string[],
 ): SlackThinkingStatusHandle {
   let cleared = false;
@@ -668,15 +635,13 @@ function setSlackThinkingStatus(
       };
     }
 
-    const addPromise = deliverChannelReply(callbackUrl, {
+    const addPromise = sendChannelReaction(callbackUrl, {
       chatId,
-      assistantId,
-      reaction: { action: "add", name: "eyes", messageTs },
+      messageId: messageTs,
+      emoji: "eyes",
+      action: "add",
     }).catch((err) => {
-      log.debug(
-        { err, chatId, messageTs },
-        "Failed to add Slack eyes reaction",
-      );
+      log.debug({ err, chatId, messageTs }, "Failed to add eyes reaction");
     });
 
     const clearReaction = (): void => {
@@ -686,14 +651,15 @@ function setSlackThinkingStatus(
       cleared = true;
       clearTimeout(safetyTimer);
       void addPromise.then(() =>
-        deliverChannelReply(callbackUrl, {
+        sendChannelReaction(callbackUrl, {
           chatId,
-          assistantId,
-          reaction: { action: "remove", name: "eyes", messageTs },
+          messageId: messageTs,
+          emoji: "eyes",
+          action: "remove",
         }).catch((err) => {
           log.debug(
             { err, chatId, messageTs },
-            "Failed to remove Slack eyes reaction",
+            "Failed to remove eyes reaction",
           );
         }),
       );
@@ -713,15 +679,11 @@ function setSlackThinkingStatus(
 
   // Track the set promise so clear waits for it to settle first,
   // preventing a race where clear arrives at Slack before set.
-  let statusPromise = deliverChannelReply(callbackUrl, {
+  let statusPromise = setChannelThreadStatus(callbackUrl, {
     chatId,
-    assistantId,
-    assistantThreadStatus: {
-      channel: chatId,
-      threadTs,
-      status: getRandomSlackThinkingStatus(),
-      ...(loadingMessages ? { loadingMessages } : {}),
-    },
+    threadTs,
+    status: getRandomSlackThinkingStatus(),
+    ...(loadingMessages ? { loadingMessages } : {}),
   }).catch((err) => {
     log.debug({ err, chatId, threadTs }, "Failed to set Slack thinking status");
   });
@@ -731,17 +693,13 @@ function setSlackThinkingStatus(
       return;
     }
     statusPromise = statusPromise.then(() =>
-      deliverChannelReply(callbackUrl, {
+      setChannelThreadStatus(callbackUrl, {
         chatId,
-        assistantId,
-        assistantThreadStatus: {
-          channel: chatId,
-          threadTs,
-          status: getRandomSlackThinkingStatus(),
-          ...(nextLoadingMessages
-            ? { loadingMessages: nextLoadingMessages }
-            : {}),
-        },
+        threadTs,
+        status: getRandomSlackThinkingStatus(),
+        ...(nextLoadingMessages
+          ? { loadingMessages: nextLoadingMessages }
+          : {}),
       }).catch((err) => {
         log.debug(
           { err, chatId, threadTs },
@@ -758,14 +716,10 @@ function setSlackThinkingStatus(
     cleared = true;
     clearTimeout(safetyTimer);
     void statusPromise.then(() =>
-      deliverChannelReply(callbackUrl, {
+      setChannelThreadStatus(callbackUrl, {
         chatId,
-        assistantId,
-        assistantThreadStatus: {
-          channel: chatId,
-          threadTs,
-          status: "",
-        },
+        threadTs,
+        status: "",
       }).catch((err) => {
         log.debug(
           { err, chatId, threadTs },
@@ -796,6 +750,7 @@ function startPendingApprovalPromptWatcher(params: {
   externalChatId: string;
   trustClass: TrustContext["trustClass"];
   guardianExternalUserId?: string;
+  guardianChatId?: string;
   requesterExternalUserId?: string;
   replyCallbackUrl: string;
   assistantId?: string;
@@ -807,6 +762,7 @@ function startPendingApprovalPromptWatcher(params: {
     externalChatId,
     trustClass,
     guardianExternalUserId,
+    guardianChatId,
     requesterExternalUserId,
     replyCallbackUrl,
     assistantId,
@@ -838,9 +794,17 @@ function startPendingApprovalPromptWatcher(params: {
         const info = pending[0];
         if (prompt && info && !deliveredRequestIds.has(info.requestId)) {
           deliveredRequestIds.add(info.requestId);
+          // Addressed to the guardian's own chat, not the chat the turn is
+          // running in, which can be a room that reads the tool and its
+          // command preview.
+          const promptDelivery = resolveGuardianPromptDelivery({
+            turnChatId: externalChatId,
+            turnCallbackUrl: replyCallbackUrl,
+            guardianChatId,
+          });
           const delivered = await deliverGeneratedApprovalPrompt({
-            replyCallbackUrl,
-            chatId: externalChatId,
+            replyCallbackUrl: promptDelivery.callbackUrl,
+            chatId: promptDelivery.chatId,
             sourceChannel,
             assistantId: assistantId ?? DAEMON_INTERNAL_ASSISTANT_ID,
             prompt,

package/src/runtime/routes/inbound-stages/edit-intercept.ts

@@ -11,20 +11,23 @@
  * the message's metadata via a single transactional content+metadata update,
  * so downstream renderers can surface the edited marker.
  *
- * Extracted from inbound-message-handler.ts to keep the top-level handler
- * focused on orchestration.
+ * An edit belongs to the conversation of the message it changes, so the stage
+ * resolves that message before it records anything, and an edit with no
+ * resolvable target is dropped.
  */
 import type { ChannelId } from "../../../channels/types.js";
 import {
   mergeSlackMetadata,
   readSlackMetadata,
 } from "../../../messaging/providers/slack/message-metadata.js";
+import type { MessageRow } from "../../../persistence/conversation-crud.js";
 import {
   getMessageById,
   updateMessageContent,
   updateMessageContentAndMetadata,
 } from "../../../persistence/conversation-crud.js";
 import {
+  findInboundEvent,
   findMessageBySourceId,
   recordInbound,
 } from "../../../persistence/delivery-crud.js";
@@ -71,19 +74,19 @@ export async function handleEditIntercept(
     content,
   } = params;
 
-  // Dedup the edit event itself (retried edited_message webhooks)
-  const editResult = recordInbound(
+  // Dedup the edit event itself (retried edited_message webhooks) before the
+  // lookup below, so a redelivery answers immediately instead of waiting out
+  // the retry window a second time.
+  const alreadyRecorded = findInboundEvent(
     sourceChannel,
     conversationExternalId,
     externalMessageId,
-    { sourceMessageId, sourceThreadId },
   );
-
-  if (editResult.duplicate) {
+  if (alreadyRecorded) {
     return {
       accepted: true,
       duplicate: true,
-      eventId: editResult.eventId,
+      eventId: alreadyRecorded.eventId,
     };
   }
 
@@ -117,81 +120,100 @@ export async function handleEditIntercept(
     }
   }
 
-  if (original) {
-    const newContent = content ?? "";
-    // Short-circuit no-op edits: Slack fires `message_changed` for link
-    // unfurls and other decorations where the text is identical to the
-    // previous revision. Skipping the DB write here covers that case and
-    // also drops trivially-redundant edit webhooks. We only have the
-    // authoritative previous text once the original row is located, so
-    // this check lives after the lookup.
-    const existingRow = getMessageById(original.messageId);
-    if (
-      existingRow &&
-      stringifyMessageContent(existingRow.content) === newContent
-    ) {
-      log.debug(
-        {
-          assistantId,
-          sourceChannel,
-          sourceMessageId,
-          messageId: original.messageId,
-        },
-        "Edit text unchanged; skipping update",
-      );
-      return {
-        accepted: true,
-        duplicate: false,
-        noop: true,
-        eventId: editResult.eventId,
-      };
-    }
-    if (sourceChannel === "slack") {
-      // Slack edits stamp `slackMeta.editedAt` so the chronological
-      // transcript renderer can surface the edited marker. The merge
-      // tolerates rows that lack slackMeta enrichment by synthesizing
-      // the minimum-required fields from the lookup data.
-      applySlackEditMetadata({
-        messageId: original.messageId,
-        conversationExternalId,
-        sourceMessageId,
-        sourceThreadId,
-        newContent,
-      });
-    } else {
-      updateMessageContent(original.messageId, newContent);
-    }
-    // The edit changed searchable text (the no-op guard above already returned
-    // for identical content) and this path bypasses the `addMessage` persist
-    // path, so reindex the message into the lexical index — the idempotent
-    // upsert replaces the stale Qdrant point with the edited content.
-    enqueueLexicalIndexForMessage(original.messageId);
-    log.info(
-      { assistantId, sourceMessageId, messageId: original.messageId },
-      "Updated message content from edited_message",
-    );
-  } else {
-    // For Slack, treat missing-target edits as `debug` (the row may have
-    // been compacted, never stored, or pre-date this upgrade); for other
-    // channels, retain the louder `warn` since their edit pipelines
-    // historically expect the row to exist.
+  if (!original) {
+    // Nothing to edit, and nothing to record it against: recording it anyway
+    // would resolve a conversation from the edit's own address and create one
+    // there.
+    //
+    // Slack keeps this at `debug`, since the row may have been compacted or
+    // never stored. Other channels keep the louder `warn`, since their edit
+    // pipelines expect the row to exist.
+    const missingTarget = {
+      assistantId,
+      sourceChannel,
+      conversationExternalId,
+      sourceMessageId,
+    };
     if (sourceChannel === "slack") {
-      log.debug(
-        {
-          assistantId,
-          sourceChannel,
-          channelId: conversationExternalId,
-          externalMessageId: sourceMessageId,
-        },
-        "Slack edit target not found, ignoring",
-      );
+      log.debug(missingTarget, "Slack edit target not found, ignoring");
     } else {
       log.warn(
-        { assistantId, sourceChannel, conversationExternalId, sourceMessageId },
+        missingTarget,
         "Could not find original message for edit after retries, ignoring",
       );
     }
+    return { accepted: true, duplicate: false, edited: false };
+  }
+
+  // The edit belongs to the conversation of the message it changes. Resolving
+  // one from the edit's own address would key it on the edited message's
+  // timestamp and create a conversation there.
+  const editResult = recordInbound(
+    sourceChannel,
+    conversationExternalId,
+    externalMessageId,
+    { sourceMessageId, conversationId: original.conversationId },
+  );
+  if (editResult.duplicate) {
+    // Two deliveries of one edit raced through the probe above while neither
+    // had recorded yet. The first owns the write; applying it twice would
+    // re-enqueue lexical indexing for no change.
+    return { accepted: true, duplicate: true, eventId: editResult.eventId };
+  }
+
+  const newContent = content ?? "";
+  // Short-circuit no-op edits: Slack fires `message_changed` for link
+  // unfurls and other decorations where the text is identical to the
+  // previous revision. Skipping the DB write here covers that case and
+  // also drops trivially-redundant edit webhooks. We only have the
+  // authoritative previous text once the original row is located, so
+  // this check lives after the lookup.
+  const existingRow = getMessageById(original.messageId);
+  if (
+    existingRow &&
+    stringifyMessageContent(existingRow.content) === newContent
+  ) {
+    log.debug(
+      {
+        assistantId,
+        sourceChannel,
+        sourceMessageId,
+        messageId: original.messageId,
+      },
+      "Edit text unchanged; skipping update",
+    );
+    return {
+      accepted: true,
+      duplicate: false,
+      noop: true,
+      eventId: editResult.eventId,
+    };
+  }
+  if (sourceChannel === "slack") {
+    // Slack edits stamp `slackMeta.editedAt` so the chronological
+    // transcript renderer can surface the edited marker. The merge
+    // tolerates rows that lack slackMeta enrichment by synthesizing
+    // the minimum-required fields from the lookup data.
+    applySlackEditMetadata({
+      messageId: original.messageId,
+      existingRow,
+      conversationExternalId,
+      sourceMessageId,
+      sourceThreadId,
+      newContent,
+    });
+  } else {
+    updateMessageContent(original.messageId, newContent);
   }
+  // The edit changed searchable text (the no-op guard above already returned
+  // for identical content) and this path bypasses the `addMessage` persist
+  // path, so reindex the message into the lexical index — the idempotent
+  // upsert replaces the stale Qdrant point with the edited content.
+  enqueueLexicalIndexForMessage(original.messageId);
+  log.info(
+    { assistantId, sourceMessageId, messageId: original.messageId },
+    "Updated message content from edited_message",
+  );
 
   return {
     accepted: true,
@@ -217,6 +239,8 @@ export async function handleEditIntercept(
  */
 function applySlackEditMetadata(params: {
   messageId: string;
+  /** The stored row, already read by the caller's no-op guard. */
+  existingRow: MessageRow | null;
   conversationExternalId: string;
   sourceMessageId: string;
   sourceThreadId?: string;
@@ -224,13 +248,13 @@ function applySlackEditMetadata(params: {
 }): void {
   const {
     messageId,
+    existingRow: row,
     conversationExternalId,
     sourceMessageId,
     sourceThreadId,
     newContent,
   } = params;
 
-  const row = getMessageById(messageId);
   const outerMetadata: Record<string, unknown> =
     row?.metadata != null ? safeParseRecord(row.metadata) : {};
   const existingSlackMeta =

package/src/runtime/routes/inbound-stages/guardian-reply-intercept.ts

@@ -13,6 +13,7 @@ import {
   listGuardianRequestsOrEmpty,
   listPendingRequestsByDestinationOrEmpty,
 } from "../../../channels/gateway-guardian-requests.js";
+import { audienceForReader } from "../../../channels/message-audience.js";
 import type { ChannelId } from "../../../channels/types.js";
 import { getLogger } from "../../../util/logger.js";
 import { DAEMON_INTERNAL_ASSISTANT_ID } from "../../assistant-scope.js";
@@ -44,8 +45,14 @@ export interface GuardianReplyInterceptParams {
   canonicalSenderId: string | null;
   sourceChannel: ChannelId;
   conversationExternalId: string;
-  conversationId: string;
-  eventId: string;
+  /**
+   * Conversation the message arrived in. Reactions resolve their target by the
+   * reacted card's own address and are routed before any conversation is
+   * known, so they pass none.
+   */
+  conversationId?: string;
+  /** Inbound event id, echoed on the consumed response when the caller has one. */
+  eventId?: string;
   replyCallbackUrl: string | undefined;
   trustClass: string;
   guardianPrincipalId: string | null | undefined;
@@ -190,11 +197,13 @@ export async function handleGuardianReplyIntercept(
         assistantId: DAEMON_INTERNAL_ASSISTANT_ID,
       };
       // On Slack, send guardian management replies (disambiguation, pending
-      // request lists, etc.) as ephemeral so only the guardian sees them.
-      if (sourceChannel === "slack" && (canonicalSenderId ?? rawSenderId)) {
-        routerReplyPayload.ephemeral = true;
-        routerReplyPayload.user = (canonicalSenderId ?? rawSenderId)!;
-      }
+      // request lists, etc.) so only the guardian sees them where a room is
+      // shared.
+      routerReplyPayload.audience = audienceForReader(
+        sourceChannel,
+        conversationExternalId,
+        canonicalSenderId ?? rawSenderId,
+      );
       try {
         await deliverChannelReply(replyCallbackUrl, routerReplyPayload);
       } catch (err) {
@@ -209,7 +218,7 @@ export async function handleGuardianReplyIntercept(
       response: {
         accepted: true,
         duplicate: false,
-        eventId,
+        ...(eventId ? { eventId } : {}),
         canonicalRouter: routerResult.type,
         requestId: routerResult.requestId,
       },