@vellumai/assistant 0.6.6 → 0.7.1

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

@@ -20,7 +20,8 @@ mock.module("../../../memory/delivery-status.js", () => ({
   recordProcessingFailure: () => {},
 }));
 
-import type { TrustContext } from "../../../daemon/conversation-runtime-assembly.js";
+
+import type { TrustContext } from "../../../daemon/trust-context.js";
 import {
   clearThreadTs,
   getThreadTs,
@@ -109,7 +110,6 @@ describe("processChannelMessageInBackground — slack thread mapping", () => {
       // Callback URL has no threadTs query param → channel-root event
       // that would otherwise call `clearThreadTs`.
       replyCallbackUrl: `https://example.test/deliver/slack?channel=${channelId}`,
-      mintBearerToken: () => "test-token",
     });
 
     await flush();
@@ -143,7 +143,6 @@ describe("processChannelMessageInBackground — slack thread mapping", () => {
       trustCtx,
       metadataHints: [],
       replyCallbackUrl: `https://example.test/deliver/slack?channel=${channelId}&threadTs=${newThreadTs}`,
-      mintBearerToken: () => "test-token",
     });
 
     await flush();

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

@@ -9,10 +9,13 @@
  */
 import type { ChannelId, InterfaceId } from "../../../channels/types.js";
 import { findGuardianForChannel } from "../../../contacts/contact-store.js";
-import type { TrustContext } from "../../../daemon/conversation-runtime-assembly.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 type { TrustContext } from "../../../daemon/trust-context.js";
+import { updateDeliveredSegmentCount } from "../../../memory/delivery-channels.js";
+import { linkMessage } from "../../../memory/delivery-crud.js";
+import {
+  markProcessed,
+  recordProcessingFailure,
+} from "../../../memory/delivery-status.js";
 import {
   clearThreadTs,
   extractChannelFromCallbackUrl,
@@ -71,10 +74,9 @@ export interface BackgroundProcessingParams {
   externalChatId: string;
   trustCtx: TrustContext;
   metadataHints: string[];
+  slackRuntimeContextNotice?: string;
   metadataUxBrief?: string;
   replyCallbackUrl?: string;
-  /** Factory that mints a fresh delivery JWT for each HTTP attempt. */
-  mintBearerToken: () => string;
   assistantId?: string;
   approvalCopyGenerator?: ApprovalCopyGenerator;
   commandIntent?: Record<string, unknown>;
@@ -107,9 +109,9 @@ export function processChannelMessageInBackground(
     externalChatId,
     trustCtx,
     metadataHints,
+    slackRuntimeContextNotice,
     metadataUxBrief,
     replyCallbackUrl,
-    mintBearerToken,
     assistantId,
     approvalCopyGenerator,
     commandIntent,
@@ -129,7 +131,6 @@ export function processChannelMessageInBackground(
       ? startTelegramTypingHeartbeat(
           typingCallbackUrl,
           externalChatId,
-          mintBearerToken,
           assistantId,
         )
       : undefined;
@@ -139,12 +140,7 @@ export function processChannelMessageInBackground(
       sourceChannel,
       replyCallbackUrl,
     )
-      ? setSlackThinkingStatus(
-          replyCallbackUrl!,
-          externalChatId,
-          mintBearerToken,
-          assistantId,
-        )
+      ? setSlackThinkingStatus(replyCallbackUrl!, externalChatId, assistantId)
       : undefined;
     const stopApprovalWatcher = replyCallbackUrl
       ? startPendingApprovalPromptWatcher({
@@ -155,7 +151,6 @@ export function processChannelMessageInBackground(
           guardianExternalUserId: trustCtx.guardianExternalUserId,
           requesterExternalUserId: trustCtx.requesterExternalUserId,
           replyCallbackUrl,
-          mintBearerToken,
           assistantId,
           approvalCopyGenerator,
         })
@@ -168,7 +163,6 @@ export function processChannelMessageInBackground(
           trustClass: trustCtx.trustClass,
           guardianExternalUserId: trustCtx.guardianExternalUserId,
           replyCallbackUrl,
-          mintBearerToken,
           assistantId,
         })
       : undefined;
@@ -230,24 +224,24 @@ export function processChannelMessageInBackground(
           trustContext: trustCtx,
           isInteractive: resolveRoutingState(trustCtx).promptWaitingAllowed,
           ...(cmdIntent ? { commandIntent: cmdIntent } : {}),
+          ...(slackRuntimeContextNotice ? { slackRuntimeContextNotice } : {}),
           ...(slackInbound ? { slackInbound } : {}),
         },
         sourceChannel,
         sourceInterface,
       );
-      deliveryCrud.linkMessage(eventId, userMessageId);
-      deliveryStatus.markProcessed(eventId);
+      linkMessage(eventId, userMessageId);
+      markProcessed(eventId);
 
       if (replyCallbackUrl) {
         await deliverReplyViaCallback(
           conversationId,
           externalChatId,
           replyCallbackUrl,
-          mintBearerToken(),
           assistantId,
           {
             onSegmentDelivered: (count) =>
-              deliveryChannels.updateDeliveredSegmentCount(eventId, count),
+              updateDeliveredSegmentCount(eventId, count),
           },
         );
       }
@@ -277,7 +271,7 @@ export function processChannelMessageInBackground(
         { err, conversationId },
         "Background channel message processing failed",
       );
-      deliveryStatus.recordProcessingFailure(eventId, err);
+      recordProcessingFailure(eventId, err);
     } finally {
       stopTypingHeartbeat?.();
       clearSlackThinkingStatus?.();
@@ -293,7 +287,7 @@ export function processChannelMessageInBackground(
 
 const TELEGRAM_TYPING_INTERVAL_MS = 4_000;
 
-export function shouldEmitTelegramTyping(
+function shouldEmitTelegramTyping(
   sourceChannel: ChannelId,
   replyCallbackUrl?: string,
 ): boolean {
@@ -305,10 +299,9 @@ export function shouldEmitTelegramTyping(
   }
 }
 
-export function startTelegramTypingHeartbeat(
+function startTelegramTypingHeartbeat(
   callbackUrl: string,
   chatId: string,
-  mintBearerToken: () => string,
   assistantId?: string,
 ): () => void {
   let active = true;
@@ -317,11 +310,11 @@ export function startTelegramTypingHeartbeat(
   const emitTyping = (): void => {
     if (!active || inFlight) return;
     inFlight = true;
-    void deliverChannelReply(
-      callbackUrl,
-      { chatId, chatAction: "typing", assistantId },
-      mintBearerToken(),
-    )
+    void deliverChannelReply(callbackUrl, {
+      chatId,
+      chatAction: "typing",
+      assistantId,
+    })
       .catch((err) => {
         log.debug(
           { err, chatId },
@@ -348,7 +341,7 @@ export function startTelegramTypingHeartbeat(
 // Slack Assistants API thinking status indicator
 // ---------------------------------------------------------------------------
 
-export function shouldEmitSlackReaction(
+function shouldEmitSlackReaction(
   sourceChannel: ChannelId,
   replyCallbackUrl?: string,
 ): boolean {
@@ -369,10 +362,9 @@ const SLACK_THINKING_MAX_DURATION_MS = 120_000;
  * A safety timer auto-clears the status after {@link SLACK_THINKING_MAX_DURATION_MS}
  * to prevent a stuck indicator when `processMessage` hangs.
  */
-export function setSlackThinkingStatus(
+function setSlackThinkingStatus(
   callbackUrl: string,
   chatId: string,
-  mintBearerToken: () => string,
   assistantId?: string,
 ): () => void {
   let cleared = false;
@@ -386,15 +378,11 @@ export function setSlackThinkingStatus(
     const messageTs = extractMessageTsFromCallbackUrl(callbackUrl);
     if (!messageTs) return () => {};
 
-    const addPromise = deliverChannelReply(
-      callbackUrl,
-      {
-        chatId,
-        assistantId,
-        reaction: { action: "add", name: "eyes", messageTs },
-      },
-      mintBearerToken(),
-    ).catch((err) => {
+    const addPromise = deliverChannelReply(callbackUrl, {
+      chatId,
+      assistantId,
+      reaction: { action: "add", name: "eyes", messageTs },
+    }).catch((err) => {
       log.debug(
         { err, chatId, messageTs },
         "Failed to add Slack eyes reaction",
@@ -406,15 +394,11 @@ export function setSlackThinkingStatus(
       cleared = true;
       clearTimeout(safetyTimer);
       void addPromise.then(() =>
-        deliverChannelReply(
-          callbackUrl,
-          {
-            chatId,
-            assistantId,
-            reaction: { action: "remove", name: "eyes", messageTs },
-          },
-          mintBearerToken(),
-        ).catch((err) => {
+        deliverChannelReply(callbackUrl, {
+          chatId,
+          assistantId,
+          reaction: { action: "remove", name: "eyes", messageTs },
+        }).catch((err) => {
           log.debug(
             { err, chatId, messageTs },
             "Failed to remove Slack eyes reaction",
@@ -434,19 +418,15 @@ export function setSlackThinkingStatus(
 
   // Track the set promise so clear waits for it to settle first,
   // preventing a race where clear arrives at Slack before set.
-  const setPromise = deliverChannelReply(
-    callbackUrl,
-    {
-      chatId,
-      assistantId,
-      assistantThreadStatus: {
-        channel: chatId,
-        threadTs,
-        status: "is thinking...",
-      },
+  const setPromise = deliverChannelReply(callbackUrl, {
+    chatId,
+    assistantId,
+    assistantThreadStatus: {
+      channel: chatId,
+      threadTs,
+      status: "is thinking...",
     },
-    mintBearerToken(),
-  ).catch((err) => {
+  }).catch((err) => {
     log.debug({ err, chatId, threadTs }, "Failed to set Slack thinking status");
   });
 
@@ -455,19 +435,15 @@ export function setSlackThinkingStatus(
     cleared = true;
     clearTimeout(safetyTimer);
     void setPromise.then(() =>
-      deliverChannelReply(
-        callbackUrl,
-        {
-          chatId,
-          assistantId,
-          assistantThreadStatus: {
-            channel: chatId,
-            threadTs,
-            status: "",
-          },
+      deliverChannelReply(callbackUrl, {
+        chatId,
+        assistantId,
+        assistantThreadStatus: {
+          channel: chatId,
+          threadTs,
+          status: "",
         },
-        mintBearerToken(),
-      ).catch((err) => {
+      }).catch((err) => {
         log.debug(
           { err, chatId, threadTs },
           "Failed to clear Slack thinking status",
@@ -488,7 +464,7 @@ export function setSlackThinkingStatus(
 
 const PENDING_APPROVAL_POLL_INTERVAL_MS = 300;
 
-export function startPendingApprovalPromptWatcher(params: {
+function startPendingApprovalPromptWatcher(params: {
   conversationId: string;
   sourceChannel: ChannelId;
   externalChatId: string;
@@ -496,7 +472,6 @@ export function startPendingApprovalPromptWatcher(params: {
   guardianExternalUserId?: string;
   requesterExternalUserId?: string;
   replyCallbackUrl: string;
-  mintBearerToken: () => string;
   assistantId?: string;
   approvalCopyGenerator?: ApprovalCopyGenerator;
 }): () => void {
@@ -508,7 +483,6 @@ export function startPendingApprovalPromptWatcher(params: {
     guardianExternalUserId,
     requesterExternalUserId,
     replyCallbackUrl,
-    mintBearerToken,
     assistantId,
     approvalCopyGenerator,
   } = params;
@@ -543,7 +517,6 @@ export function startPendingApprovalPromptWatcher(params: {
             chatId: externalChatId,
             sourceChannel,
             assistantId: assistantId ?? DAEMON_INTERNAL_ASSISTANT_ID,
-            bearerToken: mintBearerToken(),
             prompt,
             uiMetadata: buildApprovalUIMetadata(prompt, info),
             messageContext: {
@@ -593,14 +566,13 @@ const globalNotifiedApprovalRequestIds = new Map<string, string>();
  *
  * Only activates for trusted-contact actors with a resolvable guardian route.
  */
-export function startTrustedContactApprovalNotifier(params: {
+function startTrustedContactApprovalNotifier(params: {
   conversationId: string;
   sourceChannel: ChannelId;
   externalChatId: string;
   trustClass: TrustContext["trustClass"];
   guardianExternalUserId?: string;
   replyCallbackUrl: string;
-  mintBearerToken: () => string;
   assistantId?: string;
 }): () => void {
   const {
@@ -610,7 +582,6 @@ export function startTrustedContactApprovalNotifier(params: {
     trustClass,
     guardianExternalUserId,
     replyCallbackUrl,
-    mintBearerToken,
     assistantId,
   } = params;
 
@@ -647,15 +618,11 @@ export function startTrustedContactApprovalNotifier(params: {
           );
           const waitingText = `Waiting for ${guardianName}'s approval...`;
           try {
-            await deliverChannelReply(
-              replyCallbackUrl,
-              {
-                chatId: externalChatId,
-                text: waitingText,
-                assistantId: assistantId ?? DAEMON_INTERNAL_ASSISTANT_ID,
-              },
-              mintBearerToken(),
-            );
+            await deliverChannelReply(replyCallbackUrl, {
+              chatId: externalChatId,
+              text: waitingText,
+              assistantId: assistantId ?? DAEMON_INTERNAL_ASSISTANT_ID,
+            });
           } catch (err) {
             log.warn(
               { err, conversationId },

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

@@ -12,9 +12,8 @@
  * focused on orchestration.
  */
 import type { ChannelId } from "../../../channels/types.js";
-import { getGatewayInternalBaseUrl } from "../../../config/env.js";
+import { sendTelegramReply } from "../../../messaging/providers/telegram-bot/send.js";
 import { getLogger } from "../../../util/logger.js";
-import { mintDaemonDeliveryToken } from "../../auth/token-service.js";
 import {
   bindSessionIdentity,
   createOutboundSession,
@@ -52,7 +51,7 @@ export interface BootstrapInterceptParams {
  */
 export async function handleBootstrapIntercept(
   params: BootstrapInterceptParams,
-): Promise<Response | null> {
+): Promise<Record<string, unknown> | null> {
   const {
     isDuplicate,
     commandIntent,
@@ -108,7 +107,7 @@ export async function handleBootstrapIntercept(
     },
   );
 
-  // Deliver verification Telegram message via the gateway (fire-and-forget)
+  // Deliver verification Telegram message directly (fire-and-forget)
   deliverBootstrapVerificationTelegram(
     conversationExternalId,
     telegramBody,
@@ -119,7 +118,7 @@ export async function handleBootstrapIntercept(
   const now = Date.now();
   updateSessionDelivery(newSession.sessionId, now, 1, now + RESEND_COOLDOWN_MS);
 
-  return Response.json({
+  return ({
     accepted: true,
     duplicate: false,
     eventId,
@@ -141,43 +140,26 @@ function deliverBootstrapVerificationTelegram(
   assistantId: string,
 ): void {
   const attemptDelivery = async (): Promise<boolean> => {
-    const gatewayUrl = getGatewayInternalBaseUrl();
-    const bearerToken = mintDaemonDeliveryToken();
-    const url = `${gatewayUrl}/deliver/telegram`;
-    const resp = await fetch(url, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${bearerToken}`,
-      },
-      body: JSON.stringify({ chatId, text, assistantId }),
-    });
-    if (!resp.ok) {
-      const body = await resp.text().catch(() => "<unreadable>");
+    try {
+      await sendTelegramReply(chatId, text);
+      return true;
+    } catch (err) {
       log.error(
-        { chatId, assistantId, status: resp.status, body },
-        "Gateway /deliver/telegram failed for bootstrap verification",
+        { err, chatId, assistantId },
+        "Failed to deliver bootstrap verification Telegram message",
       );
       return false;
     }
-    return true;
   };
 
   (async () => {
-    try {
-      const delivered = await attemptDelivery();
-      if (delivered) {
-        log.info(
-          { chatId, assistantId },
-          "Bootstrap verification Telegram message delivered",
-        );
-        return;
-      }
-    } catch (err) {
-      log.error(
-        { err, chatId, assistantId },
-        "Failed to deliver bootstrap verification Telegram message",
+    const delivered = await attemptDelivery();
+    if (delivered) {
+      log.info(
+        { chatId, assistantId },
+        "Bootstrap verification Telegram message delivered",
       );
+      return;
     }
 
     // Self-retry after a short delay. The gateway deduplicates inbound
@@ -185,23 +167,16 @@ function deliverBootstrapVerificationTelegram(
     // user re-clicking the deep link may never arrive. This ensures
     // delivery is re-attempted even without a gateway duplicate.
     setTimeout(async () => {
-      try {
-        const delivered = await attemptDelivery();
-        if (delivered) {
-          log.info(
-            { chatId, assistantId },
-            "Bootstrap verification Telegram message delivered on self-retry",
-          );
-        } else {
-          log.error(
-            { chatId, assistantId },
-            "Bootstrap verification Telegram self-retry also failed",
-          );
-        }
-      } catch (retryErr) {
+      const retried = await attemptDelivery();
+      if (retried) {
+        log.info(
+          { chatId, assistantId },
+          "Bootstrap verification Telegram message delivered on self-retry",
+        );
+      } else {
         log.error(
-          { err: retryErr, chatId, assistantId },
-          "Bootstrap verification Telegram self-retry threw; giving up",
+          { chatId, assistantId },
+          "Bootstrap verification Telegram self-retry also failed",
         );
       }
     }, 3000);

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

@@ -21,7 +21,7 @@ import {
   updateMessageContent,
   updateMessageContentAndMetadata,
 } from "../../../memory/conversation-crud.js";
-import * as deliveryCrud from "../../../memory/delivery-crud.js";
+import { findMessageBySourceId, recordInbound } from "../../../memory/delivery-crud.js";
 import {
   mergeSlackMetadata,
   readSlackMetadata,
@@ -56,7 +56,7 @@ export interface EditInterceptParams {
  */
 export async function handleEditIntercept(
   params: EditInterceptParams,
-): Promise<Response> {
+): Promise<Record<string, unknown>> {
   const {
     sourceChannel,
     conversationExternalId,
@@ -69,7 +69,7 @@ export async function handleEditIntercept(
   } = params;
 
   // Dedup the edit event itself (retried edited_message webhooks)
-  const editResult = deliveryCrud.recordInbound(
+  const editResult = recordInbound(
     sourceChannel,
     conversationExternalId,
     externalMessageId,
@@ -77,7 +77,7 @@ export async function handleEditIntercept(
   );
 
   if (editResult.duplicate) {
-    return Response.json({
+    return ({
       accepted: true,
       duplicate: true,
       eventId: editResult.eventId,
@@ -98,7 +98,7 @@ export async function handleEditIntercept(
 
   let original: { messageId: string; conversationId: string } | null = null;
   for (let attempt = 0; attempt <= EDIT_LOOKUP_RETRIES; attempt++) {
-    original = deliveryCrud.findMessageBySourceId(
+    original = findMessageBySourceId(
       sourceChannel,
       conversationExternalId,
       sourceMessageId,
@@ -137,7 +137,7 @@ export async function handleEditIntercept(
         },
         "Edit text unchanged; skipping update",
       );
-      return Response.json({
+      return ({
         accepted: true,
         duplicate: false,
         noop: true,
@@ -185,7 +185,7 @@ export async function handleEditIntercept(
     }
   }
 
-  return Response.json({
+  return ({
     accepted: true,
     duplicate: false,
     eventId: editResult.eventId,

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

@@ -9,7 +9,7 @@
  */
 import type { ChannelId, InterfaceId } from "../../../channels/types.js";
 import { createCanonicalGuardianRequest } from "../../../memory/canonical-guardian-store.js";
-import * as deliveryCrud from "../../../memory/delivery-crud.js";
+import { storePayload } from "../../../memory/delivery-crud.js";
 import { emitNotificationSignal } from "../../../notifications/emit-signal.js";
 import type { NotificationSourceChannel } from "../../../notifications/signal.js";
 import { getLogger } from "../../../util/logger.js";
@@ -52,7 +52,7 @@ export interface EscalationInterceptParams {
  */
 export function handleEscalationIntercept(
   params: EscalationInterceptParams,
-): Response | null {
+): Record<string, unknown> | null {
   const {
     resolvedMember,
     canonicalAssistantId,
@@ -84,7 +84,7 @@ export function handleEscalationIntercept(
       { sourceChannel, channelId: resolvedMember.channel.id },
       "Ingress ACL: escalate policy but no guardian binding, denying",
     );
-    return Response.json({
+    return ({
       accepted: true,
       denied: true,
       reason: "escalate_no_guardian",
@@ -93,7 +93,7 @@ export function handleEscalationIntercept(
 
   // Persist the raw payload so the decide handler can recover the original
   // message content when the escalation is approved.
-  deliveryCrud.storePayload(eventId, {
+  storePayload(eventId, {
     sourceChannel,
     interface: sourceInterface,
     externalChatId: conversationExternalId,
@@ -159,7 +159,7 @@ export function handleEscalationIntercept(
     "Guardian escalation created — notification pipeline handles channel delivery",
   );
 
-  return Response.json({
+  return ({
     accepted: true,
     escalated: true,
     reason: "policy_escalate",

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

@@ -84,7 +84,6 @@ function makeParams(
     actorUsername: "alice",
     sourceMetadata: { commandIntent: { type: "start" } },
     replyCallbackUrl: "https://gateway/reply",
-    mintBearerToken: () => "token-123",
     assistantId: "self",
     externalMessageId: `msg-${messageIdCounter}`,
     ...overrides,
@@ -121,7 +120,7 @@ describe("handleGuardianActivationIntercept", () => {
     const result = await handleGuardianActivationIntercept(makeParams());
 
     expect(result).not.toBeNull();
-    const body = await result!.json();
+    const body = result!;
     expect(body).toEqual({ accepted: true, guardianActivation: true });
 
     // Verify createOutboundSession was called with correct params
@@ -229,7 +228,7 @@ describe("handleGuardianActivationIntercept", () => {
     const result = await handleGuardianActivationIntercept(makeParams());
 
     expect(result).not.toBeNull();
-    const body = await result!.json();
+    const body = result!;
     expect(body).toEqual({ accepted: true, guardianActivationPending: true });
 
     // createOutboundSession should NOT be called
@@ -260,7 +259,7 @@ describe("handleGuardianActivationIntercept", () => {
 
     // Should proceed and create a new session (superseding the stale one)
     expect(result).not.toBeNull();
-    const body = await result!.json();
+    const body = result!;
     expect(body).toEqual({ accepted: true, guardianActivation: true });
     expect(createOutboundSessionCalls).toHaveLength(1);
     expect(emitNotificationSignalCalls).toHaveLength(1);
@@ -272,7 +271,7 @@ describe("handleGuardianActivationIntercept", () => {
     // First call should process normally
     const result1 = await handleGuardianActivationIntercept(params);
     expect(result1).not.toBeNull();
-    const body1 = await result1!.json();
+    const body1 = result1!;
     expect(body1).toEqual({ accepted: true, guardianActivation: true });
     expect(createOutboundSessionCalls).toHaveLength(1);
     expect(deliverChannelReplyCalls).toHaveLength(1);
@@ -281,7 +280,7 @@ describe("handleGuardianActivationIntercept", () => {
     // Second call with same externalMessageId should be deduped
     const result2 = await handleGuardianActivationIntercept(params);
     expect(result2).not.toBeNull();
-    const body2 = await result2!.json();
+    const body2 = result2!;
     expect(body2).toEqual({ accepted: true, guardianActivation: true });
 
     // No additional session/reply/signal calls