@vellumai/assistant 0.8.2 → 0.8.4

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

@@ -4,6 +4,18 @@ const deliveredChannelReplies: Array<{
   callbackUrl: string;
   payload: Record<string, unknown>;
 }> = [];
+const markedProcessedEvents: string[] = [];
+const processingFailureEvents: string[] = [];
+const deliveredEvents: string[] = [];
+const deliveryFailureEvents: string[] = [];
+const storedReplyMessageIds: Array<{
+  eventId: string;
+  replyMessageId: string;
+}> = [];
+const replyDeliveryCalls: Array<{ messageId?: string }> = [];
+let deliverReplyViaCallbackImpl: (
+  ...args: unknown[]
+) => Promise<void> = async () => {};
 
 mock.module("../../../util/logger.js", () => ({
   getLogger: () =>
@@ -18,11 +30,24 @@ mock.module("../../../memory/delivery-channels.js", () => ({
 
 mock.module("../../../memory/delivery-crud.js", () => ({
   linkMessage: () => {},
+  storeReplyMessageId: (eventId: string, replyMessageId: string) => {
+    storedReplyMessageIds.push({ eventId, replyMessageId });
+  },
 }));
 
 mock.module("../../../memory/delivery-status.js", () => ({
-  markProcessed: () => {},
-  recordProcessingFailure: () => {},
+  markDeliveryDelivered: (eventId: string) => {
+    deliveredEvents.push(eventId);
+  },
+  markProcessed: (eventId: string) => {
+    markedProcessedEvents.push(eventId);
+  },
+  recordDeliveryFailure: (eventId: string) => {
+    deliveryFailureEvents.push(eventId);
+  },
+  recordProcessingFailure: (eventId: string) => {
+    processingFailureEvents.push(eventId);
+  },
 }));
 
 mock.module("../../gateway-client.js", () => ({
@@ -36,7 +61,11 @@ mock.module("../../gateway-client.js", () => ({
 }));
 
 mock.module("../channel-delivery-routes.js", () => ({
-  deliverReplyViaCallback: async () => {},
+  deliverReplyViaCallback: async (...args: unknown[]) => {
+    const options = args[4] as { messageId?: string } | undefined;
+    replyDeliveryCalls.push({ messageId: options?.messageId });
+    return deliverReplyViaCallbackImpl(...args);
+  },
 }));
 
 import type { TrustContext } from "../../../daemon/trust-context.js";
@@ -53,6 +82,17 @@ import {
   shouldStartSlackThinkingStatusImmediately,
 } from "./background-dispatch.js";
 
+beforeEach(() => {
+  deliveredChannelReplies.length = 0;
+  markedProcessedEvents.length = 0;
+  processingFailureEvents.length = 0;
+  deliveredEvents.length = 0;
+  deliveryFailureEvents.length = 0;
+  storedReplyMessageIds.length = 0;
+  replyDeliveryCalls.length = 0;
+  deliverReplyViaCallbackImpl = async () => {};
+});
+
 describe("isBoundGuardianActor", () => {
   test("returns true only when requester matches bound guardian", () => {
     expect(
@@ -171,9 +211,103 @@ describe("processChannelMessageInBackground — slack thread mapping", () => {
 
     clearThreadTs(conversationId);
   });
+
+  test("records callback delivery failures without failing processing", async () => {
+    const conversationId = "conv-delivery-failure";
+    const channelId = "C-DELIVERY-FAILURE";
+
+    const processMessage: MessageProcessor = async (
+      _conversationId,
+      _content,
+      _attachmentIds,
+      options,
+    ) => {
+      options?.onEvent?.({
+        type: "message_complete",
+        conversationId,
+        messageId: "assistant-msg-delivery-failure",
+      });
+      return { messageId: "user-msg-delivery-failure" };
+    };
+    deliverReplyViaCallbackImpl = async () => {
+      throw new Error("fetch failed");
+    };
+
+    processChannelMessageInBackground({
+      processMessage,
+      conversationId,
+      eventId: "evt-delivery-failure",
+      content: "please reply",
+      sourceChannel: "slack",
+      sourceInterface: "slack",
+      externalChatId: channelId,
+      trustCtx,
+      metadataHints: [],
+      replyCallbackUrl: `https://example.test/deliver/slack?channel=${channelId}`,
+    });
+
+    await flush();
+
+    expect(markedProcessedEvents).toEqual(["evt-delivery-failure"]);
+    expect(processingFailureEvents).toEqual([]);
+    expect(storedReplyMessageIds).toEqual([
+      {
+        eventId: "evt-delivery-failure",
+        replyMessageId: "assistant-msg-delivery-failure",
+      },
+    ]);
+    expect(replyDeliveryCalls).toEqual([
+      { messageId: "assistant-msg-delivery-failure" },
+    ]);
+    expect(deliveryFailureEvents).toEqual(["evt-delivery-failure"]);
+    expect(deliveredEvents).toEqual([]);
+
+    clearThreadTs(conversationId);
+  });
+
+  test("stores assistant reply ids returned by non-agent-loop fast paths", async () => {
+    const conversationId = "conv-fast-path-reply";
+    const channelId = "C-FAST-PATH";
+
+    const processMessage: MessageProcessor = async () => ({
+      messageId: "user-msg-fast-path",
+      assistantMessageId: "assistant-msg-fast-path",
+    });
+
+    processChannelMessageInBackground({
+      processMessage,
+      conversationId,
+      eventId: "evt-fast-path",
+      content: "/unknown",
+      sourceChannel: "slack",
+      sourceInterface: "slack",
+      externalChatId: channelId,
+      trustCtx,
+      metadataHints: [],
+      replyCallbackUrl: `https://example.test/deliver/slack?channel=${channelId}`,
+    });
+
+    await flush();
+
+    expect(markedProcessedEvents).toEqual(["evt-fast-path"]);
+    expect(storedReplyMessageIds).toEqual([
+      {
+        eventId: "evt-fast-path",
+        replyMessageId: "assistant-msg-fast-path",
+      },
+    ]);
+    expect(replyDeliveryCalls).toEqual([
+      { messageId: "assistant-msg-fast-path" },
+    ]);
+    expect(deliveredEvents).toEqual(["evt-fast-path"]);
+
+    clearThreadTs(conversationId);
+  });
 });
 
 describe("Slack thinking status timing", () => {
+  const slackStatusLabels = ["is on it", "is working hard", "is touching grass"];
+
   const trustCtx: TrustContext = {
     trustClass: "guardian",
     guardianExternalUserId: "guardian-1",
@@ -281,9 +415,13 @@ describe("Slack thinking status timing", () => {
         {
           channel: channelId,
           threadTs,
-          status: "is thinking...",
+          status: expect.any(String),
+          loadingMessages: ["Working on it..."],
         },
       );
+      const threadStatus = deliveredChannelReplies[0]!.payload
+        .assistantThreadStatus as { status: string };
+      expect(slackStatusLabels).toContain(threadStatus.status);
       return { messageId: "user-msg-mention-immediate" };
     };
 
@@ -309,7 +447,8 @@ describe("Slack thinking status timing", () => {
         | undefined;
       return status?.status;
     });
-    expect(statuses).toEqual(["is thinking...", ""]);
+    expect(slackStatusLabels).toContain(statuses[0]!);
+    expect(statuses[1]).toBe("");
   });
 
   test("does not set Slack thinking status for no_response text deltas", async () => {
@@ -396,6 +535,226 @@ describe("Slack thinking status timing", () => {
         | undefined;
       return status?.status;
     });
-    expect(statuses).toEqual(["is thinking...", ""]);
+    expect(slackStatusLabels).toContain(statuses[0]!);
+    expect(statuses[1]).toBe("");
+  });
+
+  test("buffers task_progress for ambiguous Slack turns until deliverable text appears", async () => {
+    const conversationId = "conv-progress-buffered";
+    const channelId = "C-PROGRESS-BUFFERED";
+    const threadTs = "1700000000.000012";
+
+    const processMessage: MessageProcessor = async (
+      _conversationId,
+      _content,
+      _attachmentIds,
+      options,
+    ) => {
+      options?.onEvent?.({
+        type: "ui_surface_show",
+        conversationId,
+        surfaceId: "surface-progress",
+        surfaceType: "card",
+        data: {
+          title: "Task progress",
+          body: "Working",
+          template: "task_progress",
+          templateData: {
+            steps: [
+              { label: "Search docs", status: "in_progress" },
+              { label: "Summarize", status: "pending" },
+            ],
+          },
+        },
+      });
+      expect(deliveredChannelReplies).toEqual([]);
+
+      options?.onEvent?.({
+        type: "assistant_text_delta",
+        text: "I found the answer.",
+        conversationId,
+      });
+      return { messageId: "user-msg-progress-buffered" };
+    };
+
+    processChannelMessageInBackground({
+      processMessage,
+      conversationId,
+      eventId: "evt-progress-buffered",
+      content: "ambient request",
+      sourceChannel: "slack",
+      sourceInterface: "slack",
+      externalChatId: channelId,
+      trustCtx,
+      metadataHints: [],
+      replyCallbackUrl: `https://example.test/deliver/slack?channel=${channelId}&threadTs=${threadTs}`,
+    });
+
+    await flush();
+
+    const statuses = deliveredChannelReplies.map(
+      (entry) => entry.payload.assistantThreadStatus,
+    );
+    expect(statuses).toEqual([
+      {
+        channel: channelId,
+        threadTs,
+        status: expect.any(String),
+        loadingMessages: ["In progress (1/2): Search docs"],
+      },
+      {
+        channel: channelId,
+        threadTs,
+        status: "",
+      },
+    ]);
+    expect(slackStatusLabels).toContain(
+      (statuses[0] as { status: string }).status,
+    );
+  });
+
+  test("keeps ambiguous Slack no_response turns quiet even with task_progress", async () => {
+    const conversationId = "conv-progress-no-response";
+    const channelId = "C-PROGRESS-NO-RESPONSE";
+    const threadTs = "1700000000.000013";
+
+    const processMessage: MessageProcessor = async (
+      _conversationId,
+      _content,
+      _attachmentIds,
+      options,
+    ) => {
+      options?.onEvent?.({
+        type: "ui_surface_show",
+        conversationId,
+        surfaceId: "surface-progress-no-response",
+        surfaceType: "card",
+        data: {
+          title: "Task progress",
+          body: "Working",
+          template: "task_progress",
+          templateData: {
+            steps: [{ label: "Inspect", status: "in_progress" }],
+          },
+        },
+      });
+      options?.onEvent?.({
+        type: "assistant_text_delta",
+        text: "<no_response/>",
+        conversationId,
+      });
+      return { messageId: "user-msg-progress-no-response" };
+    };
+
+    processChannelMessageInBackground({
+      processMessage,
+      conversationId,
+      eventId: "evt-progress-no-response",
+      content: "ambient chatter",
+      sourceChannel: "slack",
+      sourceInterface: "slack",
+      externalChatId: channelId,
+      trustCtx,
+      metadataHints: [],
+      replyCallbackUrl: `https://example.test/deliver/slack?channel=${channelId}&threadTs=${threadTs}`,
+    });
+
+    await flush();
+
+    expect(deliveredChannelReplies).toEqual([]);
+  });
+
+  test("updates Slack loading message when task_progress changes", async () => {
+    const conversationId = "conv-progress-update";
+    const channelId = "C-PROGRESS-UPDATE";
+    const threadTs = "1700000000.000014";
+
+    const processMessage: MessageProcessor = async (
+      _conversationId,
+      _content,
+      _attachmentIds,
+      options,
+    ) => {
+      options?.onEvent?.({
+        type: "ui_surface_show",
+        conversationId,
+        surfaceId: "surface-progress-update",
+        surfaceType: "card",
+        data: {
+          title: "Task progress",
+          body: "Working",
+          template: "task_progress",
+          templateData: {
+            steps: [
+              { label: "Read request", status: "in_progress" },
+              { label: "Write answer", status: "pending" },
+            ],
+          },
+        },
+      });
+      options?.onEvent?.({
+        type: "assistant_text_delta",
+        text: "On it.",
+        conversationId,
+      });
+      options?.onEvent?.({
+        type: "ui_surface_update",
+        conversationId,
+        surfaceId: "surface-progress-update",
+        data: {
+          templateData: {
+            steps: [
+              { label: "Read request", status: "completed" },
+              { label: "Write answer", status: "in_progress" },
+            ],
+          },
+        },
+      });
+      return { messageId: "user-msg-progress-update" };
+    };
+
+    processChannelMessageInBackground({
+      processMessage,
+      conversationId,
+      eventId: "evt-progress-update",
+      content: "please respond",
+      sourceChannel: "slack",
+      sourceInterface: "slack",
+      externalChatId: channelId,
+      trustCtx,
+      metadataHints: [],
+      replyCallbackUrl: `https://example.test/deliver/slack?channel=${channelId}&threadTs=${threadTs}`,
+    });
+
+    await flush();
+
+    const statuses = deliveredChannelReplies.map(
+      (entry) => entry.payload.assistantThreadStatus,
+    );
+    expect(statuses).toEqual([
+      {
+        channel: channelId,
+        threadTs,
+        status: expect.any(String),
+        loadingMessages: ["In progress (1/2): Read request"],
+      },
+      {
+        channel: channelId,
+        threadTs,
+        status: expect.any(String),
+        loadingMessages: ["In progress (2/2): Write answer"],
+      },
+      {
+        channel: channelId,
+        threadTs,
+        status: "",
+      },
+    ]);
+    expect(slackStatusLabels).toContain(
+      (statuses[0] as { status: string }).status,
+    );
+    expect(slackStatusLabels).toContain(
+      (statuses[1] as { status: string }).status,
+    );
   });
 });