@vellumai/assistant 0.5.7 → 0.5.8

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

@@ -507,6 +507,15 @@ export async function handleChannelInbound(
     !result.duplicate &&
     !guardianReplyResult.skipApprovalInterception
   ) {
+    // Extract the original approval message timestamp for Slack button
+    // cleanup. When a Slack block_actions payload is forwarded, the gateway
+    // sets sourceMetadata.messageId to the ts of the message containing
+    // the button. This lets us edit the message after resolution.
+    const approvalMessageTs =
+      sourceChannel === "slack" && typeof sourceMetadata?.messageId === "string"
+        ? sourceMetadata.messageId
+        : undefined;
+
     const approvalResult = await handleApprovalInterception({
       conversationId: result.conversationId,
       callbackData: body.callbackData,
@@ -520,6 +529,7 @@ export async function handleChannelInbound(
       assistantId: canonicalAssistantId,
       approvalCopyGenerator,
       approvalConversationGenerator,
+      approvalMessageTs,
     });
 
     if (approvalResult.handled) {
@@ -598,6 +608,27 @@ export async function handleChannelInbound(
         }
       }
 
+      // On Slack, edit the original approval message to remove stale buttons
+      // 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) => {
+          log.error(
+            { err, conversationId: result.conversationId },
+            "Failed to edit stale Slack approval message",
+          );
+        });
+      }
+
       return Response.json({
         accepted: true,
         duplicate: false,
@@ -650,7 +681,6 @@ export async function handleChannelInbound(
       mintBearerToken,
       assistantId: canonicalAssistantId,
       approvalCopyGenerator,
-      externalMessageId: sourceMessageId ?? externalMessageId,
       chatType: sourceChatType,
     });
   }

package/src/runtime/routes/inbound-stages/acl-enforcement.ts

@@ -8,7 +8,10 @@
  */
 import { isInviteCodeRedemptionEnabled } from "../../../channels/config.js";
 import type { ChannelId } from "../../../channels/types.js";
-import { findContactChannel } from "../../../contacts/contact-store.js";
+import {
+  findContactChannel,
+  findGuardianForChannel,
+} from "../../../contacts/contact-store.js";
 import { touchChannelLastSeen } from "../../../contacts/contacts-write.js";
 import type {
   ChannelStatus,
@@ -21,7 +24,10 @@ import {
   findByInviteCodeHash,
   findByInviteCodeHashAnyChannel,
 } from "../../../memory/invite-store.js";
+import { MESSAGE_PREVIEW_MAX_LENGTH } from "../../../notifications/copy-composer.js";
+import { resolveGuardianName } from "../../../prompts/user-reference.js";
 import { getLogger } from "../../../util/logger.js";
+import { truncate } from "../../../util/truncate.js";
 import { hashVoiceCode } from "../../../util/voice-code.js";
 import { notifyGuardianOfAccessRequest } from "../../access-request-helper.js";
 import { getInviteAdapterRegistry } from "../../channel-invite-transport.js";
@@ -32,6 +38,7 @@ import {
   resolveBootstrapToken,
 } from "../../channel-verification-service.js";
 import { deliverChannelReply } from "../../gateway-client.js";
+import { ensureVellumGuardianBinding } from "../../guardian-vellum-migration.js";
 import {
   redeemInvite,
   redeemInviteByCode,
@@ -40,6 +47,42 @@ import { getInviteRedemptionReply } from "../../invite-redemption-templates.js";
 
 const log = getLogger("runtime-http");
 
+/**
+ * Resolve the guardian's display name for use in requester-facing messages.
+ *
+ * Uses the assistant's anchored vellum principal to validate the guardian
+ * contact, matching the same strategy used by `notifyGuardianOfAccessRequest`.
+ * This prevents stale or cross-assistant contacts from leaking a wrong name.
+ */
+function resolveGuardianLabel(
+  sourceChannel: ChannelId,
+  canonicalAssistantId: string,
+): string {
+  const anchoredPrincipalId = ensureVellumGuardianBinding(canonicalAssistantId);
+
+  // Try source-channel guardian, but only accept it when the principal
+  // matches the assistant's anchor.
+  const sourceGuardian = findGuardianForChannel(sourceChannel);
+  if (
+    sourceGuardian &&
+    sourceGuardian.contact.principalId === anchoredPrincipalId
+  ) {
+    return resolveGuardianName(sourceGuardian.contact.displayName);
+  }
+
+  // Fall back to the vellum-channel guardian with the same anchor check.
+  const vellumGuardian = findGuardianForChannel("vellum");
+  if (
+    vellumGuardian &&
+    vellumGuardian.contact.principalId === anchoredPrincipalId
+  ) {
+    return resolveGuardianName(vellumGuardian.contact.displayName);
+  }
+
+  // No anchored guardian found — use generic fallback.
+  return resolveGuardianName(undefined);
+}
+
 // ---------------------------------------------------------------------------
 // Public API
 // ---------------------------------------------------------------------------
@@ -321,6 +364,10 @@ export async function enforceIngressAcl(
                 actorExternalId: canonicalSenderId ?? rawSenderId,
                 actorDisplayName,
                 actorUsername,
+                messagePreview: truncate(
+                  trimmedContent,
+                  MESSAGE_PREVIEW_MAX_LENGTH,
+                ),
               });
             } catch (err) {
               log.error(
@@ -349,7 +396,7 @@ export async function enforceIngressAcl(
                   dmCallbackUrl,
                   {
                     chatId: senderUserId,
-                    text: "I don't recognize you yet! I've let my owner know you're trying to reach me. They'll need to share a 6-digit verification code with you — ask them directly if you know them. Once you have the code, reply here with it.",
+                    text: `I don't recognize you yet! I've let ${resolveGuardianLabel(sourceChannel, canonicalAssistantId)} know you're trying to reach me. They'll need to share a 6-digit verification code with you — ask them directly if you know them. Once you have the code, reply here with it.`,
                     assistantId,
                   },
                   mintBearerToken(),
@@ -387,6 +434,10 @@ export async function enforceIngressAcl(
             actorExternalId: canonicalSenderId ?? rawSenderId,
             actorDisplayName,
             actorUsername,
+            messagePreview: truncate(
+              trimmedContent,
+              MESSAGE_PREVIEW_MAX_LENGTH,
+            ),
           });
           guardianNotified = accessResult.notified;
         } catch (err) {
@@ -398,7 +449,7 @@ export async function enforceIngressAcl(
 
         if (replyCallbackUrl) {
           const replyText = guardianNotified
-            ? "Hmm looks like you don't have access to talk to me. I'll let them know you tried talking to me and get back to you."
+            ? `Hmm looks like you don't have access to talk to me. I'll let ${resolveGuardianLabel(sourceChannel, canonicalAssistantId)} know you tried talking to me and get back to you.`
             : "Sorry, you haven't been approved to message this assistant.";
           const replyPayload: Parameters<typeof deliverChannelReply>[1] = {
             chatId: conversationExternalId,
@@ -579,6 +630,10 @@ export async function enforceIngressAcl(
                   previousMemberStatus: channelStatusToMemberStatus(
                     resolvedMember.channel.status,
                   ),
+                  messagePreview: truncate(
+                    trimmedContent,
+                    MESSAGE_PREVIEW_MAX_LENGTH,
+                  ),
                 });
               } catch (err) {
                 log.error(
@@ -603,7 +658,7 @@ export async function enforceIngressAcl(
                     dmCallbackUrl,
                     {
                       chatId: senderUserId,
-                      text: "I don't recognize you yet! I've let my owner know you're trying to reach me. They'll need to share a 6-digit verification code with you — ask them directly if you know them. Once you have the code, reply here with it.",
+                      text: `I don't recognize you yet! I've let ${resolveGuardianLabel(sourceChannel, canonicalAssistantId)} know you're trying to reach me. They'll need to share a 6-digit verification code with you — ask them directly if you know them. Once you have the code, reply here with it.`,
                       assistantId,
                     },
                     mintBearerToken(),
@@ -645,6 +700,10 @@ export async function enforceIngressAcl(
                 previousMemberStatus: channelStatusToMemberStatus(
                   resolvedMember.channel.status,
                 ),
+                messagePreview: truncate(
+                  trimmedContent,
+                  MESSAGE_PREVIEW_MAX_LENGTH,
+                ),
               });
               guardianNotified = accessResult.notified;
             } catch (err) {
@@ -657,7 +716,7 @@ export async function enforceIngressAcl(
 
           if (replyCallbackUrl) {
             const replyText = guardianNotified
-              ? "Hmm looks like you don't have access to talk to me. I'll let them know you tried talking to me and get back to you."
+              ? `Hmm looks like you don't have access to talk to me. I'll let ${resolveGuardianLabel(sourceChannel, canonicalAssistantId)} know you tried talking to me and get back to you.`
               : "Sorry, you haven't been approved to message this assistant.";
             const inactiveReplyPayload: Parameters<
               typeof deliverChannelReply

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

@@ -75,8 +75,6 @@ export interface BackgroundProcessingParams {
   approvalCopyGenerator?: ApprovalCopyGenerator;
   commandIntent?: Record<string, unknown>;
   sourceLanguageCode?: string;
-  /** External message ID (e.g. Slack message ts) used for reaction indicators. */
-  externalMessageId?: string;
   /** Chat type from the gateway (e.g. "private", "group", "supergroup"). */
   chatType?: string;
 }
@@ -106,7 +104,6 @@ export function processChannelMessageInBackground(
     approvalCopyGenerator,
     commandIntent,
     sourceLanguageCode,
-    externalMessageId,
     chatType,
   } = params;
 
@@ -126,18 +123,18 @@ export function processChannelMessageInBackground(
         )
       : undefined;
 
-    // Add 👀 reaction to the inbound Slack message as a processing indicator
-    const removeSlackReaction =
-      shouldEmitSlackReaction(sourceChannel, replyCallbackUrl) &&
-      externalMessageId
-        ? addSlackEyesReaction(
-            replyCallbackUrl!,
-            externalChatId,
-            externalMessageId,
-            mintBearerToken,
-            assistantId,
-          )
-        : undefined;
+    // Set Slack Assistants API "is thinking..." status indicator
+    const clearSlackThinkingStatus = shouldEmitSlackReaction(
+      sourceChannel,
+      replyCallbackUrl,
+    )
+      ? setSlackThinkingStatus(
+          replyCallbackUrl!,
+          externalChatId,
+          mintBearerToken,
+          assistantId,
+        )
+      : undefined;
     const stopApprovalWatcher = replyCallbackUrl
       ? startPendingApprovalPromptWatcher({
           conversationId,
@@ -230,7 +227,7 @@ export function processChannelMessageInBackground(
       deliveryStatus.recordProcessingFailure(eventId, err);
     } finally {
       stopTypingHeartbeat?.();
-      removeSlackReaction?.();
+      clearSlackThinkingStatus?.();
       stopApprovalWatcher?.();
       stopTcApprovalNotifier?.();
     }
@@ -295,7 +292,7 @@ export function startTelegramTypingHeartbeat(
 }
 
 // ---------------------------------------------------------------------------
-// Slack eyes reaction indicator
+// Slack Assistants API thinking status indicator
 // ---------------------------------------------------------------------------
 
 export function shouldEmitSlackReaction(
@@ -310,65 +307,80 @@ export function shouldEmitSlackReaction(
   }
 }
 
-const SLACK_EYES_MAX_DURATION_MS = 120_000;
+const SLACK_THINKING_MAX_DURATION_MS = 120_000;
 
 /**
- * Add a 👀 reaction to the inbound Slack message and return a cleanup
- * function that removes it. Both operations are fire-and-forget.
+ * Set the Slack Assistants API "is thinking..." status on the thread and
+ * return a cleanup function that clears it. Both operations are fire-and-forget.
  *
- * A safety timer auto-removes the reaction after {@link SLACK_EYES_MAX_DURATION_MS}
- * to prevent stuck eyes when `processMessage` hangs (e.g. queued behind
- * an active session turn that never completes for this message).
+ * A safety timer auto-clears the status after {@link SLACK_THINKING_MAX_DURATION_MS}
+ * to prevent a stuck indicator when `processMessage` hangs.
  */
-export function addSlackEyesReaction(
+export function setSlackThinkingStatus(
   callbackUrl: string,
   chatId: string,
-  messageTs: string,
   mintBearerToken: () => string,
   assistantId?: string,
 ): () => void {
-  let removed = false;
+  let cleared = false;
+
+  // Extract the thread timestamp from the callback URL so we can target
+  // the correct thread for the Assistants API status.
+  const threadTs = extractThreadTsFromCallbackUrl(callbackUrl);
+
+  // If there's no thread context, we can't set a thread status — bail.
+  if (!threadTs) {
+    return () => {};
+  }
 
-  // Track the add promise so remove waits for it to settle first,
-  // preventing a race where remove arrives at Slack before add.
-  const addPromise = deliverChannelReply(
+  // 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,
-      reaction: { action: "add", name: "eyes", messageTs },
+      assistantThreadStatus: {
+        channel: chatId,
+        threadTs,
+        status: "is thinking...",
+      },
     },
     mintBearerToken(),
   ).catch((err) => {
-    log.debug({ err, chatId, messageTs }, "Failed to add Slack eyes reaction");
+    log.debug({ err, chatId, threadTs }, "Failed to set Slack thinking status");
   });
 
-  const removeReaction = () => {
-    if (removed) return;
-    removed = true;
+  const clearStatus = () => {
+    if (cleared) return;
+    cleared = true;
     clearTimeout(safetyTimer);
-    void addPromise.then(() =>
+    void setPromise.then(() =>
       deliverChannelReply(
         callbackUrl,
         {
           chatId,
           assistantId,
-          reaction: { action: "remove", name: "eyes", messageTs },
+          assistantThreadStatus: {
+            channel: chatId,
+            threadTs,
+            status: "",
+          },
         },
         mintBearerToken(),
       ).catch((err) => {
         log.debug(
-          { err, chatId, messageTs },
-          "Failed to remove Slack eyes reaction",
+          { err, chatId, threadTs },
+          "Failed to clear Slack thinking status",
         );
       }),
     );
   };
 
-  const safetyTimer = setTimeout(removeReaction, SLACK_EYES_MAX_DURATION_MS);
+  const safetyTimer = setTimeout(clearStatus, SLACK_THINKING_MAX_DURATION_MS);
   (safetyTimer as { unref?: () => void }).unref?.();
 
-  return removeReaction;
+  return clearStatus;
 }
 
 // ---------------------------------------------------------------------------

package/src/runtime/routes/integrations/twilio.ts

@@ -91,10 +91,19 @@ export async function handleGetTwilioConfig(): Promise<Response> {
 export async function handleSetTwilioCredentials(
   req: Request,
 ): Promise<Response> {
-  const body = (await req.json().catch(() => ({}))) as {
-    accountSid?: string;
-    authToken?: string;
-  };
+  let body: { accountSid?: string; authToken?: string };
+  try {
+    body = (await req.json()) as typeof body;
+  } catch {
+    return Response.json(
+      {
+        success: false,
+        hasCredentials: await hasTwilioCredentials(),
+        error: "Invalid JSON in request body",
+      },
+      { status: 400 },
+    );
+  }
 
   if (!body.accountSid || !body.authToken) {
     return Response.json(
@@ -261,10 +270,19 @@ export async function handleProvisionTwilioNumber(
     });
   }
 
-  const body = (await req.json().catch(() => ({}))) as {
-    country?: string;
-    areaCode?: string;
-  };
+  let body: { country?: string; areaCode?: string };
+  try {
+    body = (await req.json()) as typeof body;
+  } catch {
+    return Response.json(
+      {
+        success: false,
+        hasCredentials: await hasTwilioCredentials(),
+        error: "Invalid JSON in request body",
+      },
+      { status: 400 },
+    );
+  }
   const { accountSid, authToken } = await getTwilioCredentials();
   const country = body.country ?? "US";
 
@@ -318,7 +336,19 @@ export async function handleProvisionTwilioNumber(
 export async function handleAssignTwilioNumber(
   req: Request,
 ): Promise<Response> {
-  const body = (await req.json().catch(() => ({}))) as { phoneNumber?: string };
+  let body: { phoneNumber?: string };
+  try {
+    body = (await req.json()) as typeof body;
+  } catch {
+    return Response.json(
+      {
+        success: false,
+        hasCredentials: await hasTwilioCredentials(),
+        error: "Invalid JSON in request body",
+      },
+      { status: 400 },
+    );
+  }
 
   if (!body.phoneNumber) {
     return Response.json(
@@ -375,7 +405,19 @@ export async function handleReleaseTwilioNumber(
     });
   }
 
-  const body = (await req.json().catch(() => ({}))) as { phoneNumber?: string };
+  let body: { phoneNumber?: string };
+  try {
+    body = (await req.json()) as typeof body;
+  } catch {
+    return Response.json(
+      {
+        success: false,
+        hasCredentials: await hasTwilioCredentials(),
+        error: "Invalid JSON in request body",
+      },
+      { status: 400 },
+    );
+  }
   const raw = loadRawConfig();
   const twilio = (raw?.twilio ?? {}) as Record<string, unknown>;
   const phoneNumber = body.phoneNumber || (twilio.phoneNumber as string) || "";

package/src/runtime/routes/memory-item-routes.test.ts

@@ -754,7 +754,7 @@ describe("Memory Item Routes", () => {
       expect(res.status).toBe(400);
     });
 
-    test("truncates long subject and statement", async () => {
+    test("preserves long subject and statement without truncation", async () => {
       const longSubject = "a".repeat(200);
       const longStatement = "b".repeat(1000);
       const ctx = makeJsonCtx("memory-items", "POST", {
@@ -767,8 +767,8 @@ describe("Memory Item Routes", () => {
       const body = (await res.json()) as {
         item: { subject: string; statement: string };
       };
-      expect(body.item.subject.length).toBeLessThanOrEqual(80);
-      expect(body.item.statement.length).toBeLessThanOrEqual(500);
+      expect(body.item.subject).toBe(longSubject);
+      expect(body.item.statement).toBe(longStatement);
     });
 
     test("enqueues embed job on create", async () => {

package/src/runtime/routes/memory-item-routes.ts

@@ -28,7 +28,6 @@ import {
   memoryItems,
 } from "../../memory/schema.js";
 import { getLogger } from "../../util/logger.js";
-import { truncate } from "../../util/truncate.js";
 import { httpError } from "../http-errors.js";
 import type { RouteContext, RouteDefinition } from "../http-router.js";
 
@@ -46,6 +45,7 @@ const VALID_KINDS = [
   "constraint",
   "event",
   "capability",
+  "journal",
 ] as const;
 
 type MemoryItemKind = (typeof VALID_KINDS)[number];
@@ -168,9 +168,7 @@ async function searchItemsSemantic(
 
     const filter = {
       must: mustConditions,
-      must_not: [
-        { key: "_meta", match: { value: true } },
-      ],
+      must_not: [{ key: "_meta", match: { value: true } }],
     };
 
     const qdrant = getQdrantClient();
@@ -260,9 +258,7 @@ export async function handleListMemoryItems(url: URL): Promise<Response> {
 
       // Re-apply the same DB-side filters used in the SQL path as defense-
       // in-depth against stale Qdrant payloads leaking deleted/mismatched rows.
-      const hydrationConditions = [
-        inArray(memoryItems.id, pageIds),
-      ];
+      const hydrationConditions = [inArray(memoryItems.id, pageIds)];
       if (statusParam && statusParam !== "all") {
         hydrationConditions.push(eq(memoryItems.status, statusParam));
       }
@@ -446,8 +442,8 @@ export async function handleCreateMemoryItem(
     );
   }
 
-  const trimmedSubject = truncate(subject.trim(), 80, "");
-  const trimmedStatement = truncate(statement.trim(), 500, "");
+  const trimmedSubject = subject.trim();
+  const trimmedStatement = statement.trim();
 
   const scopeId = "default";
   const fingerprint = computeMemoryFingerprint(
@@ -492,6 +488,7 @@ export async function handleCreateMemoryItem(
       confidence: 0.95,
       importance: importance ?? 0.8,
       fingerprint,
+      sourceType: "tool",
       verificationState: "user_confirmed",
       scopeId,
       firstSeenAt: now,
@@ -534,6 +531,7 @@ export async function handleUpdateMemoryItem(
     kind?: string;
     status?: string;
     importance?: number;
+    sourceType?: string;
     verificationState?: string;
   };
 
@@ -558,13 +556,13 @@ export async function handleUpdateMemoryItem(
     if (typeof body.subject !== "string") {
       return httpError("BAD_REQUEST", "subject must be a string", 400);
     }
-    set.subject = truncate(body.subject.trim(), 80, "");
+    set.subject = body.subject.trim();
   }
   if (body.statement !== undefined) {
     if (typeof body.statement !== "string") {
       return httpError("BAD_REQUEST", "statement must be a string", 400);
     }
-    set.statement = truncate(body.statement.trim(), 500, "");
+    set.statement = body.statement.trim();
   }
   if (body.kind !== undefined) {
     if (!isValidKind(body.kind)) {
@@ -582,8 +580,24 @@ export async function handleUpdateMemoryItem(
   if (body.importance !== undefined) {
     set.importance = body.importance;
   }
+  if (body.sourceType !== undefined) {
+    set.sourceType = body.sourceType;
+  }
+
+  // Accept verificationState from clients that haven't migrated to sourceType yet.
+  // Map verificationState → sourceType for forward compat, and write both fields.
   if (body.verificationState !== undefined) {
     set.verificationState = body.verificationState;
+    // Map verificationState to sourceType if sourceType wasn't explicitly provided
+    if (body.sourceType === undefined) {
+      set.sourceType =
+        body.verificationState === "user_confirmed" ? "tool" : "extraction";
+    }
+  }
+  // If sourceType was set (either directly or via mapping), also write verificationState
+  if (body.sourceType !== undefined && body.verificationState === undefined) {
+    set.verificationState =
+      body.sourceType === "tool" ? "user_confirmed" : "assistant_inferred";
   }
 
   // If subject, statement, or kind changed, recompute fingerprint