@vellumai/assistant 0.8.2 → 0.8.4

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

package/src/__tests__/channel-retry-sweep.test.ts

@@ -1,6 +1,6 @@
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
-import { eq } from "drizzle-orm";
+import { asc, eq } from "drizzle-orm";
 
 mock.module("../util/logger.js", () => ({
   getLogger: () =>
@@ -9,6 +9,66 @@ mock.module("../util/logger.js", () => ({
     }),
 }));
 
+const deliveryCalls: Array<{
+  conversationId: string;
+  externalChatId: string;
+  callbackUrl: string;
+  assistantId?: string;
+  messageId?: string;
+  startFromSegment?: number;
+}> = [];
+let deliverReplyViaCallbackImpl: (
+  ...args: unknown[]
+) => Promise<void> = async () => {};
+
+mock.module("../runtime/channel-reply-delivery.js", () => ({
+  deliverReplyViaCallback: async (
+    conversationId: string,
+    externalChatId: string,
+    callbackUrl: string,
+    assistantId?: string,
+    options?: { messageId?: string; startFromSegment?: number },
+  ) => {
+    deliveryCalls.push({
+      conversationId,
+      externalChatId,
+      callbackUrl,
+      assistantId,
+      messageId: options?.messageId,
+      startFromSegment: options?.startFromSegment,
+    });
+    return deliverReplyViaCallbackImpl(
+      conversationId,
+      externalChatId,
+      callbackUrl,
+      assistantId,
+      options,
+    );
+  },
+  findAssistantReplyMessageIdForTurn: (
+    conversationId: string,
+    userMessageId: string,
+  ): string | undefined => {
+    const rows = getDb()
+      .select()
+      .from(messages)
+      .where(eq(messages.conversationId, conversationId))
+      .orderBy(asc(messages.createdAt))
+      .all();
+    const userIndex = rows.findIndex((row) => row.id === userMessageId);
+    if (userIndex === -1) return undefined;
+    let candidate: string | undefined;
+    for (let i = userIndex + 1; i < rows.length; i++) {
+      const row = rows[i];
+      if (row.role === "user") break;
+      if (row.role === "assistant") {
+        candidate = row.id;
+      }
+    }
+    return candidate;
+  },
+}));
+
 import { getDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
 import * as deliveryCrud from "../memory/delivery-crud.js";
@@ -97,6 +157,8 @@ function seedFailedEventWithActorRoleOnly(
 describe("channel-retry-sweep", () => {
   beforeEach(() => {
     resetTables();
+    deliveryCalls.length = 0;
+    deliverReplyViaCallbackImpl = async () => {};
   });
 
   test("replays canonical payloads with trustClass correctly", async () => {
@@ -296,4 +358,215 @@ describe("channel-retry-sweep", () => {
     expect(capturedOptions?.trustContext?.sourceChannel).toBe("telegram");
     expect(capturedOptions?.isInteractive).toBe(false);
   });
+
+  test("delivery failure after successful replay does not requeue processing", async () => {
+    const inbound = deliveryCrud.recordInbound(
+      "telegram",
+      "chat-delivery-fails",
+      "msg-delivery-fails",
+    );
+    deliveryCrud.storePayload(inbound.eventId, {
+      content: "retry me",
+      sourceChannel: "telegram",
+      interface: "telegram",
+      externalChatId: "chat-delivery-fails",
+      replyCallbackUrl: "https://example.test/deliver/telegram",
+      trustCtx: {
+        trustClass: "unknown",
+        sourceChannel: "telegram",
+        requesterChatId: "chat-delivery-fails",
+      },
+    });
+
+    const db = getDb();
+    db.update(channelInboundEvents)
+      .set({
+        processingStatus: "failed",
+        processingAttempts: 1,
+        retryAfter: Date.now() - 1,
+      })
+      .where(eq(channelInboundEvents.id, inbound.eventId))
+      .run();
+    deliverReplyViaCallbackImpl = async () => {
+      throw new Error("fetch failed");
+    };
+
+    let processMessageCalls = 0;
+    await sweepFailedEvents(async (conversationId, _content, _ids, options) => {
+      processMessageCalls++;
+      options?.onEvent?.({
+        type: "message_complete",
+        conversationId,
+        messageId: "assistant-delivery-fails",
+      });
+      const messageId = "message-delivery-fails";
+      db.insert(messages)
+        .values({
+          id: messageId,
+          conversationId,
+          role: "user",
+          content: JSON.stringify([{ type: "text", text: "retry me" }]),
+          createdAt: Date.now(),
+        })
+        .run();
+      return { messageId };
+    });
+
+    const row = db
+      .select()
+      .from(channelInboundEvents)
+      .where(eq(channelInboundEvents.id, inbound.eventId))
+      .get();
+    expect(processMessageCalls).toBe(1);
+    expect(deliveryCalls).toHaveLength(1);
+    expect(row?.processingStatus).toBe("processed");
+    expect(row?.deliveryStatus).toBe("failed");
+    expect(row?.messageId).toBe("message-delivery-fails");
+    expect(
+      row?.rawPayload ? JSON.parse(row.rawPayload).replyMessageId : undefined,
+    ).toBe("assistant-delivery-fails");
+  });
+
+  test("delivery retry for processed events resumes delivery without processing", async () => {
+    const inbound = deliveryCrud.recordInbound(
+      "telegram",
+      "chat-delivery-only",
+      "msg-delivery-only",
+    );
+    deliveryCrud.storePayload(inbound.eventId, {
+      content: "already processed",
+      sourceChannel: "telegram",
+      interface: "telegram",
+      externalChatId: "chat-delivery-only",
+      replyCallbackUrl: "https://example.test/deliver/telegram",
+      assistantId: "assistant-1",
+      replyMessageId: "assistant-delivery-only",
+    });
+
+    const db = getDb();
+    db.update(channelInboundEvents)
+      .set({
+        processingStatus: "processed",
+        deliveryStatus: "failed",
+        processingAttempts: 1,
+        retryAfter: Date.now() - 1,
+        deliveredSegmentCount: 2,
+      })
+      .where(eq(channelInboundEvents.id, inbound.eventId))
+      .run();
+
+    let processMessageCalls = 0;
+    await sweepFailedEvents(async () => {
+      processMessageCalls++;
+      throw new Error("processMessage should not be called");
+    });
+
+    const row = db
+      .select()
+      .from(channelInboundEvents)
+      .where(eq(channelInboundEvents.id, inbound.eventId))
+      .get();
+    expect(processMessageCalls).toBe(0);
+    expect(deliveryCalls).toEqual([
+      {
+        conversationId: inbound.conversationId,
+        externalChatId: "chat-delivery-only",
+        callbackUrl: "https://example.test/deliver/telegram",
+        assistantId: "assistant-1",
+        messageId: "assistant-delivery-only",
+        startFromSegment: 2,
+      },
+    ]);
+    expect(row?.processingStatus).toBe("processed");
+    expect(row?.deliveryStatus).toBe("delivered");
+    expect(row?.retryAfter).toBeNull();
+  });
+
+  test("delivery retry resolves missing reply id from the linked user turn", async () => {
+    const inbound = deliveryCrud.recordInbound(
+      "telegram",
+      "chat-delivery-fallback",
+      "msg-delivery-fallback",
+    );
+    deliveryCrud.storePayload(inbound.eventId, {
+      content: "already processed",
+      sourceChannel: "telegram",
+      interface: "telegram",
+      externalChatId: "chat-delivery-fallback",
+      replyCallbackUrl: "https://example.test/deliver/telegram",
+      assistantId: "assistant-1",
+    });
+
+    const db = getDb();
+    db.insert(messages)
+      .values([
+        {
+          id: "user-delivery-fallback",
+          conversationId: inbound.conversationId,
+          role: "user",
+          content: JSON.stringify([
+            { type: "text", text: "already processed" },
+          ]),
+          createdAt: 1_000,
+        },
+        {
+          id: "assistant-delivery-fallback",
+          conversationId: inbound.conversationId,
+          role: "assistant",
+          content: JSON.stringify([{ type: "text", text: "reply" }]),
+          createdAt: 1_001,
+        },
+        {
+          id: "user-unrelated",
+          conversationId: inbound.conversationId,
+          role: "user",
+          content: JSON.stringify([{ type: "text", text: "newer turn" }]),
+          createdAt: 1_002,
+        },
+        {
+          id: "assistant-unrelated",
+          conversationId: inbound.conversationId,
+          role: "assistant",
+          content: JSON.stringify([{ type: "text", text: "newer reply" }]),
+          createdAt: 1_003,
+        },
+      ])
+      .run();
+    deliveryCrud.linkMessage(inbound.eventId, "user-delivery-fallback");
+    db.update(channelInboundEvents)
+      .set({
+        processingStatus: "processed",
+        deliveryStatus: "failed",
+        retryAfter: Date.now() - 1,
+      })
+      .where(eq(channelInboundEvents.id, inbound.eventId))
+      .run();
+
+    let processMessageCalls = 0;
+    await sweepFailedEvents(async () => {
+      processMessageCalls++;
+      throw new Error("processMessage should not be called");
+    });
+
+    const row = db
+      .select()
+      .from(channelInboundEvents)
+      .where(eq(channelInboundEvents.id, inbound.eventId))
+      .get();
+    expect(processMessageCalls).toBe(0);
+    expect(deliveryCalls).toEqual([
+      {
+        conversationId: inbound.conversationId,
+        externalChatId: "chat-delivery-fallback",
+        callbackUrl: "https://example.test/deliver/telegram",
+        assistantId: "assistant-1",
+        messageId: "assistant-delivery-fallback",
+        startFromSegment: 0,
+      },
+    ]);
+    expect(
+      row?.rawPayload ? JSON.parse(row.rawPayload).replyMessageId : undefined,
+    ).toBe("assistant-delivery-fallback");
+    expect(row?.deliveryStatus).toBe("delivered");
+  });
 });

package/src/__tests__/compaction-events.test.ts

@@ -52,7 +52,7 @@ mock.module("../memory/guardian-action-store.js", () => ({
 
 mock.module("../providers/registry.js", () => ({
   getProvider: () => ({ name: "mock-provider" }),
-  initializeProviders: () => {},
+  initializeProviders: async () => {},
 }));
 
 mock.module("../config/loader.js", () => ({