@vellumai/assistant 0.6.5 → 0.7.0

package/src/runtime/routes/inbound-message-handler.ts

@@ -12,24 +12,36 @@ import {
   parseInterfaceId,
 } from "../../channels/types.js";
 import { touchContactInteraction } from "../../contacts/contacts-write.js";
-import type { TrustContext } from "../../daemon/conversation-runtime-assembly.js";
-import type { HeartbeatService } from "../../heartbeat/heartbeat-service.js";
-import * as attachmentsStore from "../../memory/attachments-store.js";
+import {
+  createApprovalConversationGenerator,
+  createApprovalCopyGenerator,
+} from "../../daemon/approval-generators.js";
+import { processMessage } from "../../daemon/process-message.js";
+import type { TrustContext } from "../../daemon/trust-context.js";
+import { HeartbeatService } from "../../heartbeat/heartbeat-service.js";
+import { getAttachmentsByIds } from "../../memory/attachments-store.js";
 import {
   recordConversationSeenSignal,
   type SignalType,
 } from "../../memory/conversation-attention-store.js";
 import {
   addMessage,
-  countMessagesWithSlackMeta,
   getMessageById,
   getMessages,
+  selectSlackMetaCandidateMetadata,
   updateMessageMetadata,
 } from "../../memory/conversation-crud.js";
-import * as deliveryChannels from "../../memory/delivery-channels.js";
-import * as deliveryCrud from "../../memory/delivery-crud.js";
-import * as deliveryStatus from "../../memory/delivery-status.js";
-import * as externalConversationStore from "../../memory/external-conversation-store.js";
+import {
+  clearPendingVerificationReply,
+  getPendingVerificationReply,
+} from "../../memory/delivery-channels.js";
+import {
+  findMessageBySourceId,
+  linkMessage,
+  recordInbound,
+} from "../../memory/delivery-crud.js";
+import { markProcessed } from "../../memory/delivery-status.js";
+import { upsertBinding } from "../../memory/external-conversation-store.js";
 import type { Message as ProviderMessage } from "../../messaging/provider-types.js";
 import {
   backfillDm,
@@ -45,18 +57,10 @@ import { wrapUntrustedContent } from "../../security/untrusted-content.js";
 import { canonicalizeInboundIdentity } from "../../util/canonicalize-identity.js";
 import { getLogger } from "../../util/logger.js";
 import { DAEMON_INTERNAL_ASSISTANT_ID } from "../assistant-scope.js";
-import { mintDaemonDeliveryToken } from "../auth/token-service.js";
 import { deliverChannelReply } from "../gateway-client.js";
-import { httpError } from "../http-errors.js";
-import type {
-  ApprovalConversationGenerator,
-  ApprovalCopyGenerator,
-  GuardianActionCopyGenerator,
-  GuardianFollowUpConversationGenerator,
-  MessageProcessor,
-} from "../http-types.js";
 import { resolveTrustContext } from "../trust-context-resolver.js";
 import { canonicalChannelAssistantId } from "./channel-route-shared.js";
+import { BadRequestError } from "./errors.js";
 import { handleApprovalInterception } from "./guardian-approval-interception.js";
 import { enforceIngressAcl } from "./inbound-stages/acl-enforcement.js";
 import { processChannelMessageInBackground } from "./inbound-stages/background-dispatch.js";
@@ -68,6 +72,7 @@ import { handleGuardianReplyIntercept } from "./inbound-stages/guardian-reply-in
 import { runSecretIngressCheck } from "./inbound-stages/secret-ingress-check.js";
 import { tryTranscribeAudioAttachments } from "./inbound-stages/transcribe-audio.js";
 import { handleVerificationIntercept } from "./inbound-stages/verification-intercept.js";
+import type { RouteHandlerArgs } from "./types.js";
 
 const log = getLogger("runtime-http");
 
@@ -93,28 +98,19 @@ export function _setDeleteLookupConfigForTests(
   deleteLookupDelayMs = delayMs;
 }
 
-export async function handleChannelInbound(
-  req: Request,
-  processMessage?: MessageProcessor,
-  assistantId: string = DAEMON_INTERNAL_ASSISTANT_ID,
-  approvalCopyGenerator?: ApprovalCopyGenerator,
-  approvalConversationGenerator?: ApprovalConversationGenerator,
-  _guardianActionCopyGenerator?: GuardianActionCopyGenerator,
-  _guardianFollowUpConversationGenerator?: GuardianFollowUpConversationGenerator,
-  heartbeatService?: HeartbeatService,
-): Promise<Response> {
+export async function handleChannelInbound({
+  body: rawBody = {},
+}: RouteHandlerArgs) {
   // Gateway-origin proof is enforced by route-policy middleware (svc_gateway
   // principal type required) before this handler runs. The exchange JWT
   // itself proves gateway origin.
 
-  // Factory that mints a fresh short-lived JWT for each daemon-to-gateway
-  // delivery callback. The JWT has a 60-second TTL, so long-running
-  // background operations (typing heartbeats, approval watchers, reply
-  // delivery) must call this at each delivery attempt rather than reusing
-  // a single token from request start.
-  const mintBearerToken = (): string => mintDaemonDeliveryToken();
+  const assistantId = DAEMON_INTERNAL_ASSISTANT_ID;
+  const approvalCopyGenerator = createApprovalCopyGenerator();
+  const approvalConversationGenerator = createApprovalConversationGenerator();
+  const heartbeatService = HeartbeatService.getInstance();
 
-  const body = (await req.json()) as {
+  const body = rawBody as {
     sourceChannel?: string;
     interface?: string;
     conversationExternalId?: string;
@@ -141,53 +137,49 @@ export async function handleChannelInbound(
   } = body;
 
   if (!body.sourceChannel || typeof body.sourceChannel !== "string") {
-    return httpError("BAD_REQUEST", "sourceChannel is required", 400);
+    throw new BadRequestError("sourceChannel is required");
   }
   // Validate and narrow to canonical ChannelId at the boundary — the gateway
   // only sends well-known channel strings, so an unknown value is rejected.
   if (!isChannelId(body.sourceChannel)) {
-    return httpError(
-      "BAD_REQUEST",
+    throw new BadRequestError(
       `Invalid sourceChannel: ${
         body.sourceChannel
       }. Valid values: ${CHANNEL_IDS.join(", ")}`,
-      400,
     );
   }
 
   const sourceChannel = body.sourceChannel;
 
   if (!body.interface || typeof body.interface !== "string") {
-    return httpError("BAD_REQUEST", "interface is required", 400);
+    throw new BadRequestError("interface is required");
   }
   const sourceInterface = parseInterfaceId(body.interface);
   if (!sourceInterface) {
-    return httpError(
-      "BAD_REQUEST",
+    throw new BadRequestError(
       `Invalid interface: ${body.interface}. Valid values: ${INTERFACE_IDS.join(
         ", ",
       )}`,
-      400,
     );
   }
 
   if (!conversationExternalId || typeof conversationExternalId !== "string") {
-    return httpError("BAD_REQUEST", "conversationExternalId is required", 400);
+    throw new BadRequestError("conversationExternalId is required");
   }
   if (
     !body.actorExternalId ||
     typeof body.actorExternalId !== "string" ||
     !body.actorExternalId.trim()
   ) {
-    return httpError("BAD_REQUEST", "actorExternalId is required", 400);
+    throw new BadRequestError("actorExternalId is required");
   }
   if (!externalMessageId || typeof externalMessageId !== "string") {
-    return httpError("BAD_REQUEST", "externalMessageId is required", 400);
+    throw new BadRequestError("externalMessageId is required");
   }
 
   // Reject non-string content regardless of whether attachments are present.
   if (content != null && typeof content !== "string") {
-    return httpError("BAD_REQUEST", "content must be a string", 400);
+    throw new BadRequestError("content must be a string");
   }
 
   let trimmedContent = typeof content === "string" ? content.trim() : "";
@@ -203,11 +195,7 @@ export async function handleChannelInbound(
     !isEdit &&
     !hasCallbackData
   ) {
-    return httpError(
-      "BAD_REQUEST",
-      "content or attachmentIds is required",
-      400,
-    );
+    throw new BadRequestError("content or attachmentIds is required");
   }
 
   // Canonicalize the assistant ID so all DB-facing operations use the
@@ -253,7 +241,6 @@ export async function handleChannelInbound(
     actorUsername: body.actorUsername,
     sourceMetadata: body.sourceMetadata,
     replyCallbackUrl: body.replyCallbackUrl,
-    mintBearerToken,
     assistantId,
     externalMessageId,
   });
@@ -272,7 +259,6 @@ export async function handleChannelInbound(
     actorDisplayName: body.actorDisplayName,
     actorUsername: body.actorUsername,
     replyCallbackUrl: body.replyCallbackUrl,
-    mintBearerToken,
     assistantId,
     externalMessageId,
   });
@@ -300,7 +286,7 @@ export async function handleChannelInbound(
         { conversationExternalId },
         "Slack message_deleted event missing sourceMetadata.messageId; ignoring",
       );
-      return Response.json({ accepted: true, deleted: false });
+      return ({ accepted: true, deleted: false });
     }
 
     // Look up the stored message via the existing channel-event lookup.
@@ -314,7 +300,7 @@ export async function handleChannelInbound(
     // that window is silently dropped and the deletion signal is lost.
     let original: { messageId: string; conversationId: string } | null = null;
     for (let attempt = 0; attempt <= deleteLookupRetries; attempt++) {
-      original = deliveryCrud.findMessageBySourceId(
+      original = findMessageBySourceId(
         sourceChannel,
         conversationExternalId,
         deletedMessageTs,
@@ -341,7 +327,7 @@ export async function handleChannelInbound(
         { conversationExternalId, deletedMessageTs },
         "No stored message found for Slack delete after retries; ignoring",
       );
-      return Response.json({ accepted: true, deleted: false });
+      return ({ accepted: true, deleted: false });
     }
 
     // Merge deletedAt into the existing slackMeta sub-key. If the row has
@@ -359,7 +345,7 @@ export async function handleChannelInbound(
         },
         "Stored Slack message has no metadata; skipping delete marker",
       );
-      return Response.json({ accepted: true, deleted: false });
+      return ({ accepted: true, deleted: false });
     }
 
     let parentMetadata: Record<string, unknown>;
@@ -379,7 +365,7 @@ export async function handleChannelInbound(
         },
         "Failed to parse stored metadata; skipping delete marker",
       );
-      return Response.json({ accepted: true, deleted: false });
+      return ({ accepted: true, deleted: false });
     }
 
     const existingSlackMeta =
@@ -396,7 +382,7 @@ export async function handleChannelInbound(
         },
         "Stored Slack message has no slackMeta; skipping delete marker",
       );
-      return Response.json({ accepted: true, deleted: false });
+      return ({ accepted: true, deleted: false });
     }
 
     const updatedSlackMeta = mergeSlackMetadata(existingSlackMeta, {
@@ -418,7 +404,7 @@ export async function handleChannelInbound(
       "Marked Slack message as deleted",
     );
 
-    return Response.json({
+    return ({
       accepted: true,
       deleted: true,
       messageId: original.messageId,
@@ -426,14 +412,11 @@ export async function handleChannelInbound(
   }
 
   if (hasAttachments) {
-    const resolved = attachmentsStore.getAttachmentsByIds(attachmentIds);
+    const resolved = getAttachmentsByIds(attachmentIds);
     if (resolved.length !== attachmentIds.length) {
       const resolvedIds = new Set(resolved.map((a) => a.id));
       const missing = attachmentIds.filter((id) => !resolvedIds.has(id));
-      return Response.json(
-        { error: `Attachment IDs not found: ${missing.join(", ")}` },
-        { status: 400 },
-      );
+      throw new BadRequestError(`Attachment IDs not found: ${missing.join(", ")}`);
     }
   }
 
@@ -466,11 +449,7 @@ export async function handleChannelInbound(
       : undefined;
 
   if (isEdit && !sourceMessageId) {
-    return httpError(
-      "BAD_REQUEST",
-      "sourceMetadata.messageId is required for edits",
-      400,
-    );
+    throw new BadRequestError("sourceMetadata.messageId is required for edits");
   }
 
   // ── Edit path: update existing message content, no new agent loop ──
@@ -488,7 +467,7 @@ export async function handleChannelInbound(
   }
 
   // ── New message path ──
-  const result = deliveryCrud.recordInbound(
+  const result = recordInbound(
     sourceChannel,
     conversationExternalId,
     externalMessageId,
@@ -502,21 +481,15 @@ export async function handleChannelInbound(
   // gateway retries (duplicates) re-attempt delivery here. On success the
   // pending marker is cleared so further duplicates short-circuit normally.
   if (result.duplicate && replyCallbackUrl) {
-    const pendingReply = deliveryChannels.getPendingVerificationReply(
-      result.eventId,
-    );
+    const pendingReply = getPendingVerificationReply(result.eventId);
     if (pendingReply) {
       try {
-        await deliverChannelReply(
-          replyCallbackUrl,
-          {
-            chatId: pendingReply.chatId,
-            text: pendingReply.text,
-            assistantId: pendingReply.assistantId,
-          },
-          mintBearerToken(),
-        );
-        deliveryChannels.clearPendingVerificationReply(result.eventId);
+        await deliverChannelReply(replyCallbackUrl, {
+          chatId: pendingReply.chatId,
+          text: pendingReply.text,
+          assistantId: pendingReply.assistantId,
+        });
+        clearPendingVerificationReply(result.eventId);
         log.info(
           { eventId: result.eventId },
           "Retried pending verification reply: delivered",
@@ -527,7 +500,7 @@ export async function handleChannelInbound(
           "Retry of pending verification reply failed; will retry on next duplicate",
         );
       }
-      return Response.json({
+      return ({
         accepted: true,
         duplicate: true,
         eventId: result.eventId,
@@ -546,7 +519,7 @@ export async function handleChannelInbound(
   // self so assistant-scoped legacy routes do not overwrite each other's
   // channel binding metadata for the same chat.
   if (canonicalAssistantId === DAEMON_INTERNAL_ASSISTANT_ID) {
-    externalConversationStore.upsertBinding({
+    upsertBinding({
       conversationId: result.conversationId,
       sourceChannel,
       externalChatId: conversationExternalId,
@@ -601,7 +574,6 @@ export async function handleChannelInbound(
         sourceChannel,
         actorExternalId: canonicalSenderId ?? rawSenderId,
         replyCallbackUrl,
-        bearerToken: mintBearerToken(),
         trustCtx: trustCtxForReaction,
         assistantId: canonicalAssistantId,
         approvalCopyGenerator,
@@ -614,7 +586,7 @@ export async function handleChannelInbound(
       // transcript line. All other interception outcomes (stale_ignored,
       // non-guardian, no pending approval) fall through to persistence.
       if (reactionApprovalResult.type === "guardian_decision_applied") {
-        return Response.json({
+        return ({
           accepted: true,
           duplicate: false,
           eventId: result.eventId,
@@ -632,7 +604,7 @@ export async function handleChannelInbound(
         { conversationId: result.conversationId, eventId: result.eventId },
         "Skipping reaction persistence: missing sourceMetadata.messageId",
       );
-      return Response.json({
+      return ({
         accepted: result.accepted,
         duplicate: result.duplicate,
         eventId: result.eventId,
@@ -662,7 +634,7 @@ export async function handleChannelInbound(
       );
     }
 
-    return Response.json({
+    return ({
       accepted: result.accepted,
       duplicate: result.duplicate,
       eventId: result.eventId,
@@ -774,7 +746,6 @@ export async function handleChannelInbound(
     conversationId: result.conversationId,
     eventId: result.eventId,
     replyCallbackUrl,
-    mintBearerToken,
     assistantId,
     actorDisplayName: body.actorDisplayName,
     actorUsername: body.actorUsername,
@@ -812,7 +783,6 @@ export async function handleChannelInbound(
     conversationId: result.conversationId,
     eventId: result.eventId,
     replyCallbackUrl,
-    mintBearerToken,
     trustClass: trustCtx.trustClass,
     guardianPrincipalId: trustCtx.guardianPrincipalId,
     approvalConversationGenerator,
@@ -846,7 +816,6 @@ export async function handleChannelInbound(
       sourceChannel,
       actorExternalId: canonicalSenderId ?? rawSenderId,
       replyCallbackUrl,
-      bearerToken: mintBearerToken(),
       trustCtx,
       assistantId: canonicalAssistantId,
       approvalCopyGenerator,
@@ -893,7 +862,7 @@ export async function handleChannelInbound(
         }
       }
 
-      return Response.json({
+      return ({
         accepted: true,
         duplicate: false,
         eventId: result.eventId,
@@ -940,16 +909,12 @@ export async function handleChannelInbound(
       // and deliver an ephemeral error so the user gets visible feedback
       // instead of a silent no-op (JARVIS-299).
       if (sourceChannel === "slack" && replyCallbackUrl && approvalMessageTs) {
-        deliverChannelReply(
-          replyCallbackUrl,
-          {
-            chatId: conversationExternalId,
-            text: "This approval request has been resolved.",
-            messageTs: approvalMessageTs,
-            assistantId: canonicalAssistantId,
-          },
-          mintBearerToken(),
-        ).catch((err) => {
+        deliverChannelReply(replyCallbackUrl, {
+          chatId: conversationExternalId,
+          text: "This approval request has been resolved.",
+          messageTs: approvalMessageTs,
+          assistantId: canonicalAssistantId,
+        }).catch((err) => {
           log.error(
             { err, conversationId: result.conversationId },
             "Failed to edit stale Slack approval message",
@@ -957,7 +922,7 @@ export async function handleChannelInbound(
         });
       }
 
-      return Response.json({
+      return ({
         accepted: true,
         duplicate: false,
         eventId: result.eventId,
@@ -968,7 +933,7 @@ export async function handleChannelInbound(
 
   // For new (non-duplicate) messages, run the secret ingress check
   // synchronously, then fire off the agent loop in the background.
-  if (!result.duplicate && processMessage) {
+  if (!result.duplicate) {
     const ingressResult = runSecretIngressCheck({
       eventId: result.eventId,
       sourceChannel,
@@ -989,7 +954,7 @@ export async function handleChannelInbound(
 
     if (ingressResult.blocked) {
       // Intentional block — mark the event as processed (not failed/dead-lettered).
-      deliveryStatus.markProcessed(result.eventId);
+      markProcessed(result.eventId);
       log.info(
         {
           eventId: result.eventId,
@@ -1049,14 +1014,21 @@ export async function handleChannelInbound(
       // longer trigger backfill. Failures are non-fatal — the new message
       // proceeds without backfilled history.
       if (sourceChannel === "slack" && sourceChatType === "im") {
+        // Exclude the just-arrived webhook message from the history window —
+        // the normal inbound persistence path writes it separately, so
+        // including it here would produce duplicate user turns. Only pass a
+        // bound when we actually have a Slack ts (`<secs>.<micros>`): the
+        // fallback path writes `externalMessageId` into `channelTs`, but that
+        // identifier is not guaranteed to be a Slack ts, and Slack's
+        // `conversations.history` rejects anything that isn't a ts string.
+        const boundingTs = isSlackTs(sourceMessageId)
+          ? sourceMessageId
+          : undefined;
         await tryBackfillSlackDmIfCold({
           conversationId: result.conversationId,
           channelId: conversationExternalId,
           account: slackAccount,
-          // Exclude the just-arrived webhook message from the history window —
-          // the normal inbound persistence path writes it separately, so
-          // including it here would produce duplicate user turns.
-          latestTs: slackInbound?.channelTs,
+          latestTs: boundingTs,
         });
       }
 
@@ -1110,7 +1082,6 @@ export async function handleChannelInbound(
         commandIntent,
         sourceLanguageCode,
         replyCallbackUrl,
-        mintBearerToken,
         assistantId: canonicalAssistantId,
         approvalCopyGenerator,
         chatType: sourceChatType,
@@ -1119,7 +1090,7 @@ export async function handleChannelInbound(
     }
   }
 
-  return Response.json({
+  return ({
     accepted: result.accepted,
     duplicate: result.duplicate,
     eventId: result.eventId,
@@ -1231,8 +1202,8 @@ async function persistSlackReactionAsMessage(params: {
     { slackMeta: writeSlackMetadata(slackMeta) },
     { skipIndexing: true },
   );
-  deliveryCrud.linkMessage(params.eventId, persisted.id);
-  deliveryStatus.markProcessed(params.eventId);
+  linkMessage(params.eventId, persisted.id);
+  markProcessed(params.eventId);
 }
 
 /**
@@ -1245,16 +1216,84 @@ async function persistSlackReactionAsMessage(params: {
 const SLACK_DM_BACKFILL_WARM_THRESHOLD = 3;
 
 /**
- * Count messages in a conversation whose `metadata` carries a `slackMeta`
- * envelope, capped at the warm threshold. Delegates to the DB helper which
- * pushes both `LIKE` and `LIMIT` into SQL so a warm DM conversation never
- * scans beyond the threshold's worth of rows on the webhook critical path.
+ * Shape-check for a Slack `ts` value. Slack IDs messages by `<seconds>.<micros>`
+ * strings (e.g. `"1700000000.000100"`). The daemon also stores an
+ * `externalMessageId` derived from the gateway's dedupe key which follows a
+ * different format, so any path that feeds a ts to Slack's API
+ * (`conversations.history`'s `latest`, etc.) must shape-check first — Slack
+ * rejects non-ts arguments with `invalid_arguments`, and passing a malformed
+ * bound silently disables the intended history window.
+ */
+function isSlackTs(value: string | null | undefined): value is string {
+  return typeof value === "string" && /^\d+\.\d+$/.test(value);
+}
+
+/**
+ * Batch size used when pulling candidate rows from SQL. A bare
+ * `LIKE '%"slackMeta"%'` match can include rows whose metadata JSON is
+ * malformed or carries the literal under an unrelated key, so we fetch in
+ * batches and re-validate each candidate with Zod. The threshold is tiny
+ * (see `SLACK_DM_BACKFILL_WARM_THRESHOLD`), so a 10× batch is a trivial
+ * scan while letting a handful of bad rows not starve the count.
+ */
+const SLACK_DM_CANDIDATE_BATCH_SIZE = SLACK_DM_BACKFILL_WARM_THRESHOLD * 10;
+
+/**
+ * Absolute cap on candidate rows inspected per webhook to classify a DM as
+ * warm. If this many substring matches have been examined without reaching
+ * the valid-row threshold, treat the conversation as cold — a scan this
+ * deep already dominates the critical-path budget and the cold-start
+ * backfill path is itself idempotent against re-runs.
+ */
+const SLACK_DM_CANDIDATE_MAX_SCAN = SLACK_DM_BACKFILL_WARM_THRESHOLD * 20;
+
+/**
+ * Count messages in a conversation whose `metadata` carries a well-formed
+ * `slackMeta` envelope, capped at the warm threshold. SQL prefilters with
+ * `LIKE` + `LIMIT`/`OFFSET` so warm DM conversations never scan the full
+ * table on the webhook critical path, and each candidate is re-validated
+ * through `readSlackMetadata` — a bare substring match would otherwise
+ * wrongly count rows whose metadata is truncated, parses but fails schema
+ * validation, or happens to contain the literal `"slackMeta"` under an
+ * unrelated key. Pulls candidates in batches, continuing until either the
+ * threshold of *valid* rows is reached or the per-call scan cap is hit, so
+ * a cluster of malformed rows at the head of the scan cannot starve the
+ * count and misclassify a warm conversation as cold.
  */
 function countSlackMetaMessages(conversationId: string): number {
-  return countMessagesWithSlackMeta(
-    conversationId,
-    SLACK_DM_BACKFILL_WARM_THRESHOLD,
-  );
+  let count = 0;
+  let offset = 0;
+  while (offset < SLACK_DM_CANDIDATE_MAX_SCAN) {
+    const remaining = SLACK_DM_CANDIDATE_MAX_SCAN - offset;
+    const batchLimit = Math.min(SLACK_DM_CANDIDATE_BATCH_SIZE, remaining);
+    const candidates = selectSlackMetaCandidateMetadata(
+      conversationId,
+      batchLimit,
+      offset,
+    );
+    if (candidates.length === 0) return count;
+    for (const raw of candidates) {
+      let parent: Record<string, unknown> | null = null;
+      try {
+        const parsed = JSON.parse(raw) as unknown;
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+          parent = parsed as Record<string, unknown>;
+        }
+      } catch {
+        continue;
+      }
+      if (!parent) continue;
+      const inner = parent.slackMeta;
+      if (typeof inner !== "string") continue;
+      if (readSlackMetadata(inner)) {
+        count++;
+        if (count >= SLACK_DM_BACKFILL_WARM_THRESHOLD) return count;
+      }
+    }
+    if (candidates.length < batchLimit) return count;
+    offset += candidates.length;
+  }
+  return count;
 }
 
 /**