@vellumai/assistant 0.8.3 → 0.8.5

package/src/__tests__/channel-delivery-store.test.ts

@@ -7,6 +7,15 @@ mock.module("../util/logger.js", () => ({
     }),
 }));
 
+mock.module("../config/loader.js", () => ({
+  getConfig: () => ({
+    slack: {
+      teamId: "T123",
+      teamUrl: "https://example.slack.com/",
+    },
+  }),
+}));
+
 import { eq } from "drizzle-orm";
 
 import {
@@ -25,8 +34,11 @@ import {
 import {
   acknowledgeDelivery,
   getDeadLetterEvents,
+  getRetryableDeliveryEvents,
   getRetryableEvents,
+  markDeliveryDelivered,
   markProcessed,
+  recordDeliveryFailure,
   recordProcessingFailure,
   replayDeadLetters,
 } from "../memory/delivery-status.js";
@@ -52,6 +64,7 @@ function resetTables() {
   db.run("DELETE FROM channel_inbound_events");
   db.run("DELETE FROM messages");
   db.run("DELETE FROM conversation_keys");
+  db.run("DELETE FROM external_conversation_bindings");
   db.run("DELETE FROM conversations");
 }
 
@@ -421,6 +434,7 @@ describe("channel-delivery-store", () => {
       conversationId: result.conversationId,
       sourceChannel: "slack",
       externalChatId: "C0123ABCDEF",
+      externalChatName: "engineering",
       externalThreadId: "1710000000.000100",
     });
 
@@ -429,12 +443,105 @@ describe("channel-delivery-store", () => {
     expect(detail?.conversation.channelBinding).toMatchObject({
       sourceChannel: "slack",
       externalChatId: "C0123ABCDEF",
+      externalChatName: "engineering",
       externalThreadId: "1710000000.000100",
       slackThread: {
         channelId: "C0123ABCDEF",
         threadTs: "1710000000.000100",
+        link: {
+          appUrl:
+            "slack://channel?team=T123&id=C0123ABCDEF&message=1710000000.000100",
+          webUrl:
+            "https://example.slack.com/archives/C0123ABCDEF/p1710000000000100",
+        },
       },
+      slackChannel: {
+        channelId: "C0123ABCDEF",
+        name: "engineering",
+        link: {
+          webUrl: "https://example.slack.com/archives/C0123ABCDEF",
+        },
+      },
+    });
+  });
+
+  test("conversation detail exposes Slack channel id fallback without stored channel name", () => {
+    const result = recordInbound("slack", "C0123ABCDEF", "msg-1", {
+      sourceThreadId: "1710000000.000100",
+    });
+
+    upsertBinding({
+      conversationId: result.conversationId,
+      sourceChannel: "slack",
+      externalChatId: "C0123ABCDEF",
+      externalThreadId: "1710000000.000100",
+    });
+
+    const detail = buildConversationDetailResponse(result.conversationId);
+
+    expect(detail?.conversation.channelBinding).toMatchObject({
+      sourceChannel: "slack",
+      externalChatId: "C0123ABCDEF",
+      externalChatName: "C0123ABCDEF",
+      slackChannel: {
+        channelId: "C0123ABCDEF",
+        name: "C0123ABCDEF",
+        link: {
+          webUrl: "https://example.slack.com/archives/C0123ABCDEF",
+        },
+      },
+    });
+  });
+
+  test("binding upsert preserves existing chat name when incoming name is missing", () => {
+    const result = recordInbound("slack", "C0123ABCDEF", "msg-1", {
+      sourceThreadId: "1710000000.000100",
+    });
+
+    upsertBinding({
+      conversationId: result.conversationId,
+      sourceChannel: "slack",
+      externalChatId: "C0123ABCDEF",
+      externalChatName: "engineering",
+      externalThreadId: "1710000000.000100",
     });
+    upsertBinding({
+      conversationId: result.conversationId,
+      sourceChannel: "slack",
+      externalChatId: "C0123ABCDEF",
+      externalThreadId: "1710000000.000100",
+    });
+
+    expect(
+      getBindingByChannelChatThread("slack", "C0123ABCDEF", "1710000000.000100")
+        ?.externalChatName,
+    ).toBe("engineering");
+  });
+
+  test("binding upsert preserves existing chat name when incoming name is blank", () => {
+    const result = recordInbound("slack", "C0123ABCDEF", "msg-1", {
+      sourceThreadId: "1710000000.000100",
+    });
+
+    upsertBinding({
+      conversationId: result.conversationId,
+      sourceChannel: "slack",
+      externalChatId: "C0123ABCDEF",
+      externalChatName: "engineering",
+      externalThreadId: "1710000000.000100",
+    });
+    upsertBinding({
+      conversationId: result.conversationId,
+      sourceChannel: "slack",
+      externalChatId: "C0123ABCDEF",
+      externalChatName: "   ",
+      externalThreadId: "1710000000.000100",
+    });
+
+    expect(
+      getBindingByChannelChatThread("slack", "C0123ABCDEF", "1710000000.000100")
+        ?.externalChatName,
+    ).toBe("engineering");
   });
 
   // ── Deduplication ─────────────────────────────────────────────────
@@ -506,11 +613,97 @@ describe("channel-delivery-store", () => {
     expect(row!.deliveryStatus).toBe("delivered");
   });
 
+  test("acknowledgeDelivery accepts late acks after retryable delivery failure", () => {
+    const result = recordInbound("telegram", "chat-1", "msg-1");
+    markProcessed(result.eventId);
+    recordDeliveryFailure(result.eventId, new Error("fetch failed"));
+
+    const ack = acknowledgeDelivery("telegram", "chat-1", "msg-1");
+    expect(ack).toBe(true);
+
+    const db = getDb();
+    const row = db
+      .select()
+      .from(channelInboundEvents)
+      .where(eq(channelInboundEvents.id, result.eventId))
+      .get();
+    expect(row!.deliveryStatus).toBe("delivered");
+    expect(row!.retryAfter).toBeNull();
+  });
+
   test("acknowledgeDelivery returns false for unknown event", () => {
     const ack = acknowledgeDelivery("telegram", "chat-1", "nonexistent");
     expect(ack).toBe(false);
   });
 
+  test("delivery failures are retryable without changing processing status", () => {
+    const result = recordInbound("telegram", "chat-1", "msg-1");
+    markProcessed(result.eventId);
+
+    recordDeliveryFailure(result.eventId, new Error("fetch failed"));
+
+    const db = getDb();
+    let row = db
+      .select()
+      .from(channelInboundEvents)
+      .where(eq(channelInboundEvents.id, result.eventId))
+      .get();
+    expect(row!.processingStatus).toBe("processed");
+    expect(row!.deliveryStatus).toBe("failed");
+    expect(row!.processingAttempts).toBe(0);
+    expect(row!.deliveryAttempts).toBe(1);
+    expect(row!.lastProcessingError).toBe("fetch failed");
+    expect(row!.retryAfter).toBeGreaterThan(0);
+
+    db.update(channelInboundEvents)
+      .set({ retryAfter: Date.now() - 10_000, deliveredSegmentCount: 2 })
+      .where(eq(channelInboundEvents.id, result.eventId))
+      .run();
+
+    const retryable = getRetryableDeliveryEvents();
+    expect(retryable).toHaveLength(1);
+    expect(retryable[0].id).toBe(result.eventId);
+    expect(retryable[0].deliveredSegmentCount).toBe(2);
+
+    markDeliveryDelivered(result.eventId);
+
+    row = db
+      .select()
+      .from(channelInboundEvents)
+      .where(eq(channelInboundEvents.id, result.eventId))
+      .get();
+    expect(row!.processingStatus).toBe("processed");
+    expect(row!.deliveryStatus).toBe("delivered");
+    expect(row!.retryAfter).toBeNull();
+    expect(getRetryableDeliveryEvents()).toHaveLength(0);
+  });
+
+  test("delivery dead letters are listed and replayed as delivery retries", () => {
+    const result = recordInbound("telegram", "chat-1", "msg-1");
+    markProcessed(result.eventId);
+
+    recordDeliveryFailure(result.eventId, { status: 400, message: "bad" });
+
+    const deadLetters = getDeadLetterEvents();
+    expect(deadLetters).toHaveLength(1);
+    expect(deadLetters[0].id).toBe(result.eventId);
+
+    const count = replayDeadLetters([result.eventId]);
+    expect(count).toBe(1);
+
+    const db = getDb();
+    const row = db
+      .select()
+      .from(channelInboundEvents)
+      .where(eq(channelInboundEvents.id, result.eventId))
+      .get();
+    expect(row!.processingStatus).toBe("processed");
+    expect(row!.deliveryStatus).toBe("failed");
+    expect(row!.deliveryAttempts).toBe(0);
+    expect(row!.lastProcessingError).toBeNull();
+    expect(row!.retryAfter).toBeGreaterThan(0);
+  });
+
   // ── Processing status transitions ─────────────────────────────────
 
   test("markProcessed sets processingStatus to processed", () => {

package/src/__tests__/channel-guardian.test.ts

@@ -2777,7 +2777,7 @@ describe("outbound voice verification", () => {
     }
   });
 
-  test("start_outbound rejects unsupported channels", async () => {
+  test("start_outbound succeeds for email channel", async () => {
     const { lastResponse } = createResponseReader();
     await handleChannelVerificationSession(
       {
@@ -2790,8 +2790,8 @@ describe("outbound voice verification", () => {
 
     const resp = lastResponse();
     expect(resp).not.toBeNull();
-    expect(resp!.success).toBe(false);
-    expect(resp!.error).toBe("unsupported_channel");
+    expect(resp!.success).toBe(true);
+    expect(resp!.channel).toBe("email");
   });
 
   test("create_session without destination falls through to inbound challenge", async () => {

package/src/__tests__/channel-reply-delivery.test.ts

@@ -34,7 +34,7 @@ const updateMessageMetadataCalls: UpdateMessageMetadataCall[] = [];
 /** Per-test override for the synthetic Slack `ts` returned by deliverChannelReply. */
 let nextDeliveryTs: string | null = null;
 
-let renderedHistoryContent: {
+type RenderedHistoryStub = {
   text: string;
   textSegments: string[];
   toolCalls: unknown[];
@@ -42,7 +42,9 @@ let renderedHistoryContent: {
   contentOrder: string[];
   surfaces: unknown[];
   thinkingSegments: string[];
-} = {
+};
+
+let renderedHistoryContent: RenderedHistoryStub = {
   text: "",
   textSegments: [],
   toolCalls: [],
@@ -51,6 +53,7 @@ let renderedHistoryContent: {
   surfaces: [],
   thinkingSegments: [],
 };
+const renderedHistoryContentQueue: RenderedHistoryStub[] = [];
 
 let deliveryFailAtIndex = -1;
 
@@ -100,6 +103,16 @@ mock.module("../memory/conversation-crud.js", () => ({
   getConversationOriginInterface: () => null,
   getConversationOriginChannel: () => null,
   getMessages: () => conversationMessages,
+  getMessagesAfter: (
+    _conversationId: string,
+    afterMessageId: string | null,
+  ) => {
+    if (!afterMessageId) return conversationMessages;
+    const index = conversationMessages.findIndex(
+      (message) => message.id === afterMessageId,
+    );
+    return index === -1 ? [] : conversationMessages.slice(index + 1);
+  },
   getMessageById: (messageId: string) =>
     conversationMessages.find((m) => m.id === messageId) ?? null,
   updateMessageMetadata: (
@@ -120,14 +133,19 @@ mock.module("../memory/conversation-crud.js", () => ({
 mock.module("../memory/attachments-store.js", () => ({
   getAttachmentMetadataForMessage: (messageId: string) =>
     attachmentsByMessageId.get(messageId) ?? [],
+  getFilePathForAttachment: () => null,
 }));
 
 mock.module("../daemon/handlers/shared.js", () => ({
-  renderHistoryContent: () => renderedHistoryContent,
+  renderHistoryContent: () =>
+    renderedHistoryContentQueue.shift() ?? renderedHistoryContent,
 }));
 
-const { deliverRenderedReplyViaCallback, deliverReplyViaCallback } =
-  await import("../runtime/channel-reply-delivery.js");
+const {
+  deliverRenderedReplyViaCallback,
+  deliverReplyViaCallback,
+  findAssistantReplyMessageIdForTurn,
+} = await import("../runtime/channel-reply-delivery.js");
 
 describe("channel-reply-delivery", () => {
   beforeEach(() => {
@@ -137,6 +155,7 @@ describe("channel-reply-delivery", () => {
     attachmentsByMessageId.clear();
     updateMessageMetadataCalls.length = 0;
     nextDeliveryTs = null;
+    renderedHistoryContentQueue.length = 0;
     renderedHistoryContent = {
       text: "",
       textSegments: [],
@@ -148,6 +167,49 @@ describe("channel-reply-delivery", () => {
     };
   });
 
+  it("finds the assistant reply in the linked user turn", () => {
+    conversationMessages.push(
+      {
+        id: "user-target",
+        role: "user",
+        content: "target",
+      },
+      {
+        id: "assistant-tool-call",
+        role: "assistant",
+        content: "tool call",
+      },
+      {
+        id: "assistant-target",
+        role: "assistant",
+        content: "final reply",
+      },
+      {
+        id: "user-newer",
+        role: "user",
+        content: "newer",
+      },
+      {
+        id: "assistant-newer",
+        role: "assistant",
+        content: "newer reply",
+      },
+    );
+    renderedHistoryContentQueue.push({
+      text: "Final reply.",
+      textSegments: ["Final reply."],
+      toolCalls: [],
+      toolCallsBeforeText: false,
+      contentOrder: ["text:0"],
+      surfaces: [],
+      thinkingSegments: [],
+    });
+
+    expect(findAssistantReplyMessageIdForTurn("conv-1", "user-target")).toBe(
+      "assistant-target",
+    );
+  });
+
   it("sends non-empty text segments as separate messages and puts attachments on the last segment", async () => {
     const attachments: RuntimeAttachmentMetadata[] = [
       {
@@ -261,6 +323,155 @@ describe("channel-reply-delivery", () => {
     });
   });
 
+  it("falls back to current-turn assistant text when the newest assistant row is tool-only", async () => {
+    conversationMessages.push(
+      { id: "msg-old-user", role: "user", content: "old prompt" },
+      {
+        id: "msg-old-assistant",
+        role: "assistant",
+        content: '[{"type":"text","text":"old answer"}]',
+      },
+      { id: "msg-current-user", role: "user", content: "current prompt" },
+      {
+        id: "msg-current-text",
+        role: "assistant",
+        content: '[{"type":"text","text":"current answer"}]',
+      },
+      {
+        id: "msg-current-tool-result",
+        role: "user",
+        content: '[{"type":"tool_result","tool_use_id":"tu-1","content":"ok"}]',
+      },
+      {
+        id: "msg-current-tool-only",
+        role: "assistant",
+        content:
+          '[{"type":"tool_use","id":"tu-2","name":"remember","input":{}}]',
+      },
+    );
+    renderedHistoryContentQueue.push(
+      {
+        text: "",
+        textSegments: [],
+        toolCalls: [{ name: "remember", input: {} }],
+        toolCallsBeforeText: true,
+        contentOrder: ["tool:0"],
+        surfaces: [],
+        thinkingSegments: [],
+      },
+      {
+        text: "Current answer.",
+        textSegments: ["Current answer."],
+        toolCalls: [],
+        toolCallsBeforeText: false,
+        contentOrder: ["text:0"],
+        surfaces: [],
+        thinkingSegments: [],
+      },
+      {
+        text: "Current answer.",
+        textSegments: ["Current answer."],
+        toolCalls: [],
+        toolCallsBeforeText: false,
+        contentOrder: ["text:0"],
+        surfaces: [],
+        thinkingSegments: [],
+      },
+    );
+
+    await deliverReplyViaCallback(
+      "conv-1",
+      "chat-current",
+      "http://gateway/deliver/slack",
+      "assistant-current",
+      { sinceMessageId: "msg-current-user" },
+    );
+
+    expect(deliveryCalls).toHaveLength(1);
+    expect(deliveryCalls[0].payload.text).toBe("Current answer.");
+  });
+
+  it("does not cross the current user boundary when no current-turn assistant text exists", async () => {
+    conversationMessages.push(
+      { id: "msg-old-user", role: "user", content: "old prompt" },
+      {
+        id: "msg-old-assistant",
+        role: "assistant",
+        content: '[{"type":"text","text":"old answer"}]',
+      },
+      { id: "msg-current-user", role: "user", content: "current prompt" },
+      {
+        id: "msg-current-tool-only",
+        role: "assistant",
+        content:
+          '[{"type":"tool_use","id":"tu-1","name":"remember","input":{}}]',
+      },
+    );
+    renderedHistoryContentQueue.push({
+      text: "",
+      textSegments: [],
+      toolCalls: [{ name: "remember", input: {} }],
+      toolCallsBeforeText: true,
+      contentOrder: ["tool:0"],
+      surfaces: [],
+      thinkingSegments: [],
+    });
+
+    await deliverReplyViaCallback(
+      "conv-1",
+      "chat-current",
+      "http://gateway/deliver/slack",
+      "assistant-current",
+      { sinceMessageId: "msg-current-user" },
+    );
+
+    expect(deliveryCalls).toHaveLength(0);
+  });
+
+  it("treats a current-turn no_response marker as terminal instead of falling back", async () => {
+    conversationMessages.push(
+      { id: "msg-current-user", role: "user", content: "current prompt" },
+      {
+        id: "msg-current-text",
+        role: "assistant",
+        content: '[{"type":"text","text":"current answer"}]',
+      },
+      {
+        id: "msg-current-silent",
+        role: "assistant",
+        content: '[{"type":"text","text":"<no_response/>"}]',
+      },
+    );
+    renderedHistoryContentQueue.push({
+      text: "<no_response/>",
+      textSegments: ["<no_response/>"],
+      toolCalls: [],
+      toolCallsBeforeText: false,
+      contentOrder: ["text:0"],
+      surfaces: [],
+      thinkingSegments: [],
+    });
+    renderedHistoryContentQueue.push({
+      text: "<no_response/>",
+      textSegments: ["<no_response/>"],
+      toolCalls: [],
+      toolCallsBeforeText: false,
+      contentOrder: ["text:0"],
+      surfaces: [],
+      thinkingSegments: [],
+    });
+
+    await deliverReplyViaCallback(
+      "conv-1",
+      "chat-current",
+      "http://gateway/deliver/slack",
+      "assistant-current",
+      { sinceMessageId: "msg-current-user" },
+    );
+
+    expect(deliveryCalls).toHaveLength(0);
+  });
+
   it("skips already-delivered segments when startFromSegment is set", async () => {
     await deliverRenderedReplyViaCallback({
       callbackUrl: "http://gateway/deliver/telegram",
@@ -485,6 +696,74 @@ describe("channel-reply-delivery", () => {
     expect(delivered).toEqual([2, 3]);
   });
 
+  it("targets an explicit assistant message instead of the latest reply", async () => {
+    conversationMessages.push(
+      { id: "msg-u", role: "user", content: "hi" },
+      { id: "msg-old", role: "assistant", content: '"old reply"' },
+      { id: "msg-new", role: "assistant", content: '"new reply"' },
+    );
+    attachmentsByMessageId.set("msg-old", [
+      {
+        id: "att-old",
+        originalFilename: "old.txt",
+        mimeType: "text/plain",
+        sizeBytes: 11,
+        kind: "uploaded",
+      },
+    ]);
+    attachmentsByMessageId.set("msg-new", [
+      {
+        id: "att-new",
+        originalFilename: "new.txt",
+        mimeType: "text/plain",
+        sizeBytes: 22,
+        kind: "uploaded",
+      },
+    ]);
+    renderedHistoryContent = {
+      text: "Reply.",
+      textSegments: ["Reply."],
+      toolCalls: [],
+      toolCallsBeforeText: false,
+      contentOrder: ["text:0"],
+      surfaces: [],
+      thinkingSegments: [],
+    };
+
+    await deliverReplyViaCallback(
+      "conv-target",
+      "chat-target",
+      "http://gateway/deliver/telegram",
+      "assistant-3",
+      { messageId: "msg-old" },
+    );
+
+    expect(deliveryCalls).toHaveLength(1);
+    expect(deliveryCalls[0].payload.attachments).toEqual([
+      {
+        id: "att-old",
+        filename: "old.txt",
+        mimeType: "text/plain",
+        sizeBytes: 11,
+        kind: "uploaded",
+      },
+    ]);
+  });
+
+  it("rejects an explicit target that is not an assistant message", async () => {
+    conversationMessages.push({ id: "msg-u", role: "user", content: "hi" });
+
+    await expect(
+      deliverReplyViaCallback(
+        "conv-target",
+        "chat-target",
+        "http://gateway/deliver/telegram",
+        "assistant-3",
+        { messageId: "msg-u" },
+      ),
+    ).rejects.toThrow("Target assistant reply message not found");
+  });
+
   // ── slackMeta.channelTs reconciliation (post-send) ─────────────────────
   // These tests close the gap where outbound assistant messages were
   // persisted with a partial slackMeta lacking `channelTs`. The renderer