@vellumai/assistant 0.6.3 → 0.6.5

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

@@ -1,6 +1,36 @@
-import { describe, expect, test } from "bun:test";
+import { describe, expect, mock, test } from "bun:test";
 
-import { isBoundGuardianActor } from "./background-dispatch.js";
+mock.module("../../../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+mock.module("../../../memory/delivery-channels.js", () => ({
+  updateDeliveredSegmentCount: () => {},
+}));
+
+mock.module("../../../memory/delivery-crud.js", () => ({
+  linkMessage: () => {},
+}));
+
+mock.module("../../../memory/delivery-status.js", () => ({
+  markProcessed: () => {},
+  recordProcessingFailure: () => {},
+}));
+
+import type { TrustContext } from "../../../daemon/conversation-runtime-assembly.js";
+import {
+  clearThreadTs,
+  getThreadTs,
+  setThreadTs,
+} from "../../../memory/slack-thread-store.js";
+import type { MessageProcessor } from "../../http-types.js";
+import {
+  isBoundGuardianActor,
+  processChannelMessageInBackground,
+} from "./background-dispatch.js";
 
 describe("isBoundGuardianActor", () => {
   test("returns true only when requester matches bound guardian", () => {
@@ -42,3 +72,84 @@ describe("isBoundGuardianActor", () => {
     ).toBe(false);
   });
 });
+
+describe("processChannelMessageInBackground — slack thread mapping", () => {
+  const trustCtx: TrustContext = {
+    trustClass: "guardian",
+    guardianExternalUserId: "guardian-1",
+    requesterExternalUserId: "guardian-1",
+  } as unknown as TrustContext;
+
+  const flush = (): Promise<void> =>
+    new Promise((resolve) => setTimeout(resolve, 10));
+
+  test("restores prior thread mapping when processMessage is rejected as already-processing", async () => {
+    const conversationId = "conv-restore-on-busy";
+    const channelId = "C-RESTORE";
+    const inFlightThreadTs = "1700000000.000001";
+
+    // Simulate a prior threaded turn that installed the mapping and is
+    // still in flight when a new channel-root event arrives.
+    setThreadTs(conversationId, channelId, inFlightThreadTs);
+
+    const processMessage: MessageProcessor = async () => {
+      throw new Error("Conversation is already processing a message");
+    };
+
+    processChannelMessageInBackground({
+      processMessage,
+      conversationId,
+      eventId: "evt-1",
+      content: "root-level message",
+      sourceChannel: "slack",
+      sourceInterface: "slack",
+      externalChatId: channelId,
+      trustCtx,
+      metadataHints: [],
+      // 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();
+
+    // The in-flight threaded turn's mapping must survive the busy rejection.
+    expect(getThreadTs(conversationId)).toBe(inFlightThreadTs);
+
+    clearThreadTs(conversationId);
+  });
+
+  test("retains updated mapping when processMessage succeeds", async () => {
+    const conversationId = "conv-retain-on-success";
+    const channelId = "C-SUCCESS";
+    const newThreadTs = "1700000000.000002";
+
+    // No prior mapping; this turn arrives in a thread and should install one.
+    clearThreadTs(conversationId);
+
+    const processMessage: MessageProcessor = async () => ({
+      messageId: "user-msg-1",
+    });
+
+    processChannelMessageInBackground({
+      processMessage,
+      conversationId,
+      eventId: "evt-2",
+      content: "thread reply",
+      sourceChannel: "slack",
+      sourceInterface: "slack",
+      externalChatId: channelId,
+      trustCtx,
+      metadataHints: [],
+      replyCallbackUrl: `https://example.test/deliver/slack?channel=${channelId}&threadTs=${newThreadTs}`,
+      mintBearerToken: () => "test-token",
+    });
+
+    await flush();
+
+    expect(getThreadTs(conversationId)).toBe(newThreadTs);
+
+    clearThreadTs(conversationId);
+  });
+});

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

@@ -14,9 +14,11 @@ 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 {
+  clearThreadTs,
   extractChannelFromCallbackUrl,
   extractMessageTsFromCallbackUrl,
   extractThreadTsFromCallbackUrl,
+  peekThreadMapping,
   setThreadTs,
 } from "../../../memory/slack-thread-store.js";
 import { resolveGuardianName } from "../../../prompts/user-reference.js";
@@ -31,6 +33,7 @@ import { deliverChannelReply } from "../../gateway-client.js";
 import type {
   ApprovalCopyGenerator,
   MessageProcessor,
+  SlackInboundMessageMetadata,
 } from "../../http-types.js";
 import { resolveRoutingState } from "../../trust-context-resolver.js";
 import { deliverReplyViaCallback } from "../channel-delivery-routes.js";
@@ -78,6 +81,12 @@ export interface BackgroundProcessingParams {
   sourceLanguageCode?: string;
   /** Chat type from the gateway (e.g. "private", "group", "supergroup"). */
   chatType?: string;
+  /**
+   * Slack-specific inbound metadata extracted at the HTTP boundary. Threaded
+   * through to `persistUserMessage` so the row can be tagged with a
+   * `slackMeta` envelope for the chronological renderer.
+   */
+  slackInbound?: SlackInboundMessageMetadata;
 }
 
 /**
@@ -106,6 +115,7 @@ export function processChannelMessageInBackground(
     commandIntent,
     sourceLanguageCode,
     chatType,
+    slackInbound,
   } = params;
 
   (async () => {
@@ -163,12 +173,32 @@ export function processChannelMessageInBackground(
         })
       : undefined;
 
-    // Track Slack thread mapping so replies go to the correct thread
+    // Align the Slack thread mapping with this turn's inbound state:
+    // set it when the inbound arrived in a thread, clear it when the
+    // inbound arrived at the channel root. `getThreadTs` is consulted
+    // at outbound-persistence time, so the mapping must reflect the
+    // current turn — a lingering mapping from a prior thread turn
+    // would otherwise be stamped onto a channel-root reply.
+    //
+    // The update must happen BEFORE `processMessage` runs because outbound
+    // persistence (inside the agent loop) reads the mapping. But if a prior
+    // threaded turn is still in flight, our `processMessage` call will be
+    // rejected as already-processing and our update would erase that
+    // in-flight turn's mapping. Snapshot the prior state here and restore
+    // it in the `already processing` rejection path below.
+    let priorSlackMapping: { threadTs: string; channelId: string } | null =
+      null;
+    let slackMappingMutated = false;
     if (sourceChannel === "slack" && replyCallbackUrl) {
+      priorSlackMapping = peekThreadMapping(conversationId);
       const inboundThreadTs = extractThreadTsFromCallbackUrl(replyCallbackUrl);
       const inboundChannel = extractChannelFromCallbackUrl(replyCallbackUrl);
       if (inboundThreadTs && inboundChannel) {
         setThreadTs(conversationId, inboundChannel, inboundThreadTs);
+        slackMappingMutated = true;
+      } else {
+        clearThreadTs(conversationId);
+        slackMappingMutated = true;
       }
     }
 
@@ -200,6 +230,7 @@ export function processChannelMessageInBackground(
           trustContext: trustCtx,
           isInteractive: resolveRoutingState(trustCtx).promptWaitingAllowed,
           ...(cmdIntent ? { commandIntent: cmdIntent } : {}),
+          ...(slackInbound ? { slackInbound } : {}),
         },
         sourceChannel,
         sourceInterface,
@@ -221,6 +252,27 @@ export function processChannelMessageInBackground(
         );
       }
     } catch (err) {
+      // When another turn is already processing this conversation,
+      // `prepareConversationForMessage` throws before any of this turn's
+      // work runs. Our pre-await mapping update would otherwise stomp the
+      // in-flight turn's mapping, causing its outbound persistence to
+      // record `slackMeta` with the wrong (or missing) `threadTs`. Restore
+      // the snapshot so the in-flight turn sees the mapping it installed.
+      if (
+        slackMappingMutated &&
+        err instanceof Error &&
+        err.message.includes("already processing a message")
+      ) {
+        if (priorSlackMapping) {
+          setThreadTs(
+            conversationId,
+            priorSlackMapping.channelId,
+            priorSlackMapping.threadTs,
+          );
+        } else {
+          clearThreadTs(conversationId);
+        }
+      }
       log.error(
         { err, conversationId },
         "Background channel message processing failed",
@@ -343,7 +395,10 @@ export function setSlackThinkingStatus(
       },
       mintBearerToken(),
     ).catch((err) => {
-      log.debug({ err, chatId, messageTs }, "Failed to add Slack eyes reaction");
+      log.debug(
+        { err, chatId, messageTs },
+        "Failed to add Slack eyes reaction",
+      );
     });
 
     const clearReaction = () => {
@@ -368,7 +423,10 @@ export function setSlackThinkingStatus(
       );
     };
 
-    const safetyTimer = setTimeout(clearReaction, SLACK_THINKING_MAX_DURATION_MS);
+    const safetyTimer = setTimeout(
+      clearReaction,
+      SLACK_THINKING_MAX_DURATION_MS,
+    );
     (safetyTimer as { unref?: () => void }).unref?.();
 
     return clearReaction;

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

@@ -7,13 +7,26 @@
  * webhook arrives before the original message has been linked via
  * linkMessage (the original agent loop may still be in progress).
  *
+ * For Slack edits, the stage additionally stamps `slackMeta.editedAt` into
+ * 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.
  */
 import type { ChannelId } from "../../../channels/types.js";
 import { touchContactInteraction } from "../../../contacts/contacts-write.js";
-import { updateMessageContent } from "../../../memory/conversation-crud.js";
+import {
+  getMessageById,
+  updateMessageContent,
+  updateMessageContentAndMetadata,
+} from "../../../memory/conversation-crud.js";
 import * as deliveryCrud from "../../../memory/delivery-crud.js";
+import {
+  mergeSlackMetadata,
+  readSlackMetadata,
+} from "../../../messaging/providers/slack/message-metadata.js";
+import { safeParseRecord } from "../../../util/json.js";
 import { getLogger } from "../../../util/logger.js";
 
 const log = getLogger("runtime-http");
@@ -106,16 +119,70 @@ export async function handleEditIntercept(
   }
 
   if (original) {
-    updateMessageContent(original.messageId, content ?? "");
+    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 && existingRow.content === newContent) {
+      log.debug(
+        {
+          assistantId,
+          sourceChannel,
+          sourceMessageId,
+          messageId: original.messageId,
+        },
+        "Edit text unchanged; skipping update",
+      );
+      return Response.json({
+        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,
+        newContent,
+      });
+    } else {
+      updateMessageContent(original.messageId, newContent);
+    }
     log.info(
       { assistantId, sourceMessageId, messageId: original.messageId },
       "Updated message content from edited_message",
     );
   } else {
-    log.warn(
-      { assistantId, sourceChannel, conversationExternalId, sourceMessageId },
-      "Could not find original message for edit after retries, ignoring",
-    );
+    // 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 (sourceChannel === "slack") {
+      log.debug(
+        {
+          assistantId,
+          sourceChannel,
+          channelId: conversationExternalId,
+          externalMessageId: sourceMessageId,
+        },
+        "Slack edit target not found, ignoring",
+      );
+    } else {
+      log.warn(
+        { assistantId, sourceChannel, conversationExternalId, sourceMessageId },
+        "Could not find original message for edit after retries, ignoring",
+      );
+    }
   }
 
   return Response.json({
@@ -124,3 +191,59 @@ export async function handleEditIntercept(
     eventId: editResult.eventId,
   });
 }
+
+// ---------------------------------------------------------------------------
+// Internal helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Apply a Slack edit to the stored message: update content and stamp
+ * `slackMeta.editedAt` in the same transaction.
+ *
+ * If the row already has a valid `slackMeta` sub-object, the merge preserves
+ * all existing fields and only sets/refreshes `editedAt`. If the row lacks
+ * `slackMeta` enrichment, the helper synthesizes the minimum-required fields
+ * (`source`, `channelId`, `channelTs`, `eventKind`) from the values that
+ * brought us here so the resulting metadata is still readable by
+ * `readSlackMetadata`.
+ */
+function applySlackEditMetadata(params: {
+  messageId: string;
+  conversationExternalId: string;
+  sourceMessageId: string;
+  newContent: string;
+}): void {
+  const { messageId, conversationExternalId, sourceMessageId, newContent } =
+    params;
+
+  const row = getMessageById(messageId);
+  const outerMetadata: Record<string, unknown> =
+    row?.metadata != null ? safeParseRecord(row.metadata) : {};
+  const existingSlackMeta =
+    typeof outerMetadata.slackMeta === "string"
+      ? outerMetadata.slackMeta
+      : undefined;
+
+  const editedAt = Date.now();
+  const parsedExisting = readSlackMetadata(existingSlackMeta ?? null);
+
+  // When the row has no valid existing slackMeta, `mergeSlackMetadata`
+  // would produce a record missing the required fields and fail subsequent
+  // `readSlackMetadata` calls. Seed defaults from the lookup-derived facts
+  // so the post-merge value is always a valid `SlackMessageMetadata`.
+  const mergedSlackMeta = mergeSlackMetadata(existingSlackMeta ?? null, {
+    ...(parsedExisting
+      ? {}
+      : {
+          source: "slack" as const,
+          channelId: conversationExternalId,
+          channelTs: sourceMessageId,
+          eventKind: "message" as const,
+        }),
+    editedAt,
+  });
+
+  updateMessageContentAndMetadata(messageId, newContent, {
+    slackMeta: mergedSlackMeta,
+  });
+}

package/src/runtime/routes/inbound-stages/transcribe-audio.test.ts

@@ -1,6 +1,7 @@
 import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 
-import type { SpeechToTextProvider } from "../../../providers/speech-to-text/types.js";
+import type { BatchTranscriber } from "../../../stt/types.js";
+import { SttError } from "../../../stt/types.js";
 
 // ---------------------------------------------------------------------------
 // Mocks — must be set up before importing the module under test
@@ -17,7 +18,7 @@ let mockAttachments: Array<{
   thumbnailBase64: string | null;
   createdAt: number;
 }> = [];
-let mockProvider: SpeechToTextProvider | null = null;
+let mockTranscriber: BatchTranscriber | null = null;
 
 mock.module("../../../config/assistant-feature-flags.js", () => ({
   isAssistantFeatureFlagEnabled: () => mockFeatureFlagEnabled,
@@ -35,7 +36,18 @@ mock.module("../../../memory/attachments-store.js", () => ({
 }));
 
 mock.module("../../../providers/speech-to-text/resolve.js", () => ({
-  resolveSpeechToTextProvider: async () => mockProvider,
+  resolveBatchTranscriber: async () => mockTranscriber,
+}));
+
+mock.module("../../../stt/daemon-batch-transcriber.js", () => ({
+  normalizeSttError: (err: unknown): SttError => {
+    if (err instanceof SttError) return err;
+    const message = err instanceof Error ? err.message : String(err);
+    if (err instanceof Error && err.name === "AbortError") {
+      return new SttError("timeout", message);
+    }
+    return new SttError("provider-error", message);
+  },
 }));
 
 mock.module("../../../util/logger.js", () => ({
@@ -105,7 +117,7 @@ describe("tryTranscribeAudioAttachments", () => {
   beforeEach(() => {
     mockFeatureFlagEnabled = true;
     mockAttachments = [];
-    mockProvider = null;
+    mockTranscriber = null;
   });
 
   afterEach(() => {
@@ -115,7 +127,9 @@ describe("tryTranscribeAudioAttachments", () => {
   test("audio attachment is transcribed and returns transcribed result", async () => {
     const audio = makeAudioAttachment("a1");
     mockAttachments = [audio];
-    mockProvider = {
+    mockTranscriber = {
+      providerId: "openai-whisper",
+      boundaryId: "daemon-batch",
       transcribe: async () => ({ text: "Hello, how are you?" }),
     };
 
@@ -131,7 +145,9 @@ describe("tryTranscribeAudioAttachments", () => {
     const doc = makeDocumentAttachment("d1");
     const img = makeImageAttachment("i1");
     mockAttachments = [doc, img];
-    mockProvider = {
+    mockTranscriber = {
+      providerId: "openai-whisper",
+      boundaryId: "daemon-batch",
       transcribe: async () => ({ text: "should not be called" }),
     };
 
@@ -140,23 +156,26 @@ describe("tryTranscribeAudioAttachments", () => {
     expect(result).toEqual({ status: "no_audio" });
   });
 
-  test("no API key returns no_provider with helpful reason string", async () => {
+  test("no provider returns no_provider with service-agnostic reason", async () => {
     const audio = makeAudioAttachment("a1");
     mockAttachments = [audio];
-    mockProvider = null; // No provider resolved
+    mockTranscriber = null; // No transcriber resolved
 
     const result = await tryTranscribeAudioAttachments(["a1"]);
 
     expect(result.status).toBe("no_provider");
-    expect((result as { reason: string }).reason).toContain(
-      "No OpenAI API key configured",
-    );
+    const reason = (result as { reason: string }).reason;
+    expect(reason).toContain("speech-to-text");
+    expect(reason).toContain("voice message transcription");
+    expect(reason).not.toContain("OpenAI");
   });
 
   test("API failure returns error with reason", async () => {
     const audio = makeAudioAttachment("a1");
     mockAttachments = [audio];
-    mockProvider = {
+    mockTranscriber = {
+      providerId: "openai-whisper",
+      boundaryId: "daemon-batch",
       transcribe: async () => {
         throw new Error("API rate limit exceeded");
       },
@@ -183,29 +202,9 @@ describe("tryTranscribeAudioAttachments", () => {
   test("30-second timeout fires and returns error without blocking", async () => {
     const audio = makeAudioAttachment("a1");
     mockAttachments = [audio];
-    mockProvider = {
-      transcribe: async (_audio, _mime, signal) => {
-        // Simulate a provider that respects the abort signal
-        return new Promise((_resolve, reject) => {
-          if (signal?.aborted) {
-            reject(new DOMException("The operation was aborted", "AbortError"));
-            return;
-          }
-          const onAbort = () => {
-            reject(new DOMException("The operation was aborted", "AbortError"));
-          };
-          signal?.addEventListener("abort", onAbort, { once: true });
-        });
-      },
-    };
-
-    // The timeout is 30s in the real code, but the test's mock provider
-    // aborts immediately when signaled. We verify the error path works
-    // by checking the result type. For a true timeout test we'd need
-    // to override the timeout constant, but this confirms the abort
-    // path produces the correct result.
-    // Instead, let's test with a provider that checks signal state:
-    mockProvider = {
+    mockTranscriber = {
+      providerId: "openai-whisper",
+      boundaryId: "daemon-batch",
       transcribe: async () => {
         throw new DOMException("The operation was aborted", "AbortError");
       },
@@ -225,7 +224,9 @@ describe("tryTranscribeAudioAttachments", () => {
     mockAttachments = [a1, a2];
 
     let callCount = 0;
-    mockProvider = {
+    mockTranscriber = {
+      providerId: "openai-whisper",
+      boundaryId: "daemon-batch",
       transcribe: async () => {
         callCount++;
         return { text: callCount === 1 ? "First message" : "Second message" };
@@ -247,7 +248,9 @@ describe("tryTranscribeAudioAttachments", () => {
     mockAttachments = [audio, doc];
 
     let transcribeCallCount = 0;
-    mockProvider = {
+    mockTranscriber = {
+      providerId: "openai-whisper",
+      boundaryId: "daemon-batch",
       transcribe: async () => {
         transcribeCallCount++;
         return { text: "Voice transcription" };
@@ -264,7 +267,9 @@ describe("tryTranscribeAudioAttachments", () => {
   });
 
   test("empty attachment IDs returns no_audio", async () => {
-    mockProvider = {
+    mockTranscriber = {
+      providerId: "openai-whisper",
+      boundaryId: "daemon-batch",
       transcribe: async () => ({ text: "should not be called" }),
     };
 
@@ -276,7 +281,9 @@ describe("tryTranscribeAudioAttachments", () => {
   test("attachment with empty transcription returns no_audio", async () => {
     const audio = makeAudioAttachment("a1");
     mockAttachments = [audio];
-    mockProvider = {
+    mockTranscriber = {
+      providerId: "openai-whisper",
+      boundaryId: "daemon-batch",
       transcribe: async () => ({ text: "   " }), // whitespace-only
     };
 

package/src/runtime/routes/inbound-stages/transcribe-audio.ts

@@ -10,7 +10,8 @@
 import { isAssistantFeatureFlagEnabled } from "../../../config/assistant-feature-flags.js";
 import { getConfig } from "../../../config/loader.js";
 import * as attachmentsStore from "../../../memory/attachments-store.js";
-import { resolveSpeechToTextProvider } from "../../../providers/speech-to-text/resolve.js";
+import { resolveBatchTranscriber } from "../../../providers/speech-to-text/resolve.js";
+import { normalizeSttError } from "../../../stt/daemon-batch-transcriber.js";
 import { getLogger } from "../../../util/logger.js";
 
 const log = getLogger("transcribe-audio");
@@ -55,13 +56,13 @@ export async function tryTranscribeAudioAttachments(
       return { status: "no_audio" };
     }
 
-    // Resolve STT provider
-    const provider = await resolveSpeechToTextProvider();
-    if (!provider) {
+    // Resolve STT provider via daemon batch transcriber facade
+    const transcriber = await resolveBatchTranscriber();
+    if (!transcriber) {
       return {
         status: "no_provider",
         reason:
-          "No OpenAI API key configured. Set one up to enable voice message transcription.",
+          "No speech-to-text provider configured. Add an API key for your STT service to enable voice message transcription.",
       };
     }
 
@@ -89,11 +90,11 @@ export async function tryTranscribeAudioAttachments(
         }
 
         const buffer = Buffer.from(hydrated.dataBase64, "base64");
-        const result = await provider.transcribe(
-          buffer,
-          attachment.mimeType,
-          abortController.signal,
-        );
+        const result = await transcriber.transcribe({
+          audio: buffer,
+          mimeType: attachment.mimeType,
+          signal: abortController.signal,
+        });
 
         if (result.text.trim()) {
           transcriptions.push(result.text.trim());
@@ -109,12 +110,11 @@ export async function tryTranscribeAudioAttachments(
       clearTimeout(timeoutId);
     }
   } catch (err: unknown) {
+    const sttErr = normalizeSttError(err);
     const reason =
-      err instanceof Error
-        ? err.name === "AbortError"
-          ? "Transcription timed out"
-          : err.message
-        : String(err);
+      sttErr.category === "timeout"
+        ? "Transcription timed out"
+        : sttErr.message;
     log.warn({ err }, "Audio transcription failed");
     return { status: "error", reason };
   }