@vellumai/assistant 0.4.16 → 0.4.18

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

@@ -1,6 +1,6 @@
-import { beforeEach, describe, expect, it, mock } from 'bun:test';
+import { beforeEach, describe, expect, it, mock } from "bun:test";
 
-import type { RuntimeAttachmentMetadata } from '../runtime/http-types.js';
+import type { RuntimeAttachmentMetadata } from "../runtime/http-types.js";
 
 type DeliveryCall = {
   callbackUrl: string;
@@ -9,14 +9,21 @@ type DeliveryCall = {
 };
 
 const deliveryCalls: DeliveryCall[] = [];
-const conversationMessages: Array<{ id: string; role: string; content: string }> = [];
-const attachmentsByMessageId = new Map<string, Array<{
+const conversationMessages: Array<{
   id: string;
-  originalFilename?: string;
-  mimeType?: string;
-  sizeBytes?: number;
-  kind?: string;
-}>>();
+  role: string;
+  content: string;
+}> = [];
+const attachmentsByMessageId = new Map<
+  string,
+  Array<{
+    id: string;
+    originalFilename?: string;
+    mimeType?: string;
+    sizeBytes?: number;
+    kind?: string;
+  }>
+>();
 
 let renderedHistoryContent: {
   text: string;
@@ -26,7 +33,7 @@ let renderedHistoryContent: {
   contentOrder: string[];
   surfaces: unknown[];
 } = {
-  text: '',
+  text: "",
   textSegments: [],
   toolCalls: [],
   toolCallsBeforeText: false,
@@ -36,29 +43,32 @@ let renderedHistoryContent: {
 
 let deliveryFailAtIndex = -1;
 
-mock.module('../runtime/gateway-client.js', () => ({
+mock.module("../runtime/gateway-client.js", () => ({
   deliverChannelReply: async (
     callbackUrl: string,
     payload: Record<string, unknown>,
     bearerToken?: string,
   ) => {
-    if (deliveryFailAtIndex >= 0 && deliveryCalls.length === deliveryFailAtIndex) {
-      throw new Error('Simulated delivery failure (502)');
+    if (
+      deliveryFailAtIndex >= 0 &&
+      deliveryCalls.length === deliveryFailAtIndex
+    ) {
+      throw new Error("Simulated delivery failure (502)");
     }
     deliveryCalls.push({ callbackUrl, payload, bearerToken });
   },
 }));
 
-mock.module('../memory/conversation-store.js', () => ({
-  getConversationThreadType: () => 'default',
+mock.module("../memory/conversation-store.js", () => ({
+  getConversationThreadType: () => "default",
   setConversationOriginChannelIfUnset: () => {},
   updateConversationContextWindow: () => {},
   deleteMessageById: () => {},
   updateConversationTitle: () => {},
   updateConversationUsage: () => {},
-  addMessage: () => ({ id: 'mock-msg-id' }),
+  addMessage: () => ({ id: "mock-msg-id" }),
   getConversation: () => ({
-    id: 'conv-1',
+    id: "conv-1",
     contextSummary: null,
     contextCompactedMessageCount: 0,
     totalInputTokens: 0,
@@ -66,30 +76,35 @@ mock.module('../memory/conversation-store.js', () => ({
     totalEstimatedCost: 0,
     title: null,
   }),
-  provenanceFromGuardianContext: () => ({ source: 'user', guardianContext: undefined }),
+  provenanceFromGuardianContext: () => ({
+    source: "user",
+    guardianContext: undefined,
+  }),
   getConversationOriginInterface: () => null,
   getConversationOriginChannel: () => null,
   getMessages: () => conversationMessages,
 }));
 
-mock.module('../memory/attachments-store.js', () => ({
-  getAttachmentMetadataForMessage: (messageId: string) => attachmentsByMessageId.get(messageId) ?? [],
+mock.module("../memory/attachments-store.js", () => ({
+  getAttachmentMetadataForMessage: (messageId: string) =>
+    attachmentsByMessageId.get(messageId) ?? [],
 }));
 
-mock.module('../daemon/handlers.js', () => ({
+mock.module("../daemon/handlers.js", () => ({
   renderHistoryContent: () => renderedHistoryContent,
 }));
 
-const { deliverRenderedReplyViaCallback, deliverReplyViaCallback } = await import('../runtime/channel-reply-delivery.js');
+const { deliverRenderedReplyViaCallback, deliverReplyViaCallback } =
+  await import("../runtime/channel-reply-delivery.js");
 
-describe('channel-reply-delivery', () => {
+describe("channel-reply-delivery", () => {
   beforeEach(() => {
     deliveryCalls.length = 0;
     deliveryFailAtIndex = -1;
     conversationMessages.length = 0;
     attachmentsByMessageId.clear();
     renderedHistoryContent = {
-      text: '',
+      text: "",
       textSegments: [],
       toolCalls: [],
       toolCallsBeforeText: false,
@@ -98,130 +113,144 @@ describe('channel-reply-delivery', () => {
     };
   });
 
-  it('sends non-empty text segments as separate messages and puts attachments on the last segment', async () => {
+  it("sends non-empty text segments as separate messages and puts attachments on the last segment", async () => {
     const attachments: RuntimeAttachmentMetadata[] = [
-      { id: 'att-1', filename: 'file.txt', mimeType: 'text/plain', sizeBytes: 5, kind: 'uploaded' },
+      {
+        id: "att-1",
+        filename: "file.txt",
+        mimeType: "text/plain",
+        sizeBytes: 5,
+        kind: "uploaded",
+      },
     ];
 
     await deliverRenderedReplyViaCallback({
-      callbackUrl: 'http://gateway/deliver/telegram',
-      chatId: 'chat-1',
-      textSegments: ['Before tool.', '   ', '', 'After tool.'],
-      fallbackText: 'Before tool.After tool.',
+      callbackUrl: "http://gateway/deliver/telegram",
+      chatId: "chat-1",
+      textSegments: ["Before tool.", "   ", "", "After tool."],
+      fallbackText: "Before tool.After tool.",
       attachments,
-      assistantId: 'assistant-1',
-      bearerToken: 'token',
+      assistantId: "assistant-1",
+      bearerToken: "token",
       interSegmentDelayMs: 0,
     });
 
     expect(deliveryCalls).toHaveLength(2);
     expect(deliveryCalls[0]).toEqual({
-      callbackUrl: 'http://gateway/deliver/telegram',
+      callbackUrl: "http://gateway/deliver/telegram",
       payload: {
-        chatId: 'chat-1',
-        text: 'Before tool.',
+        chatId: "chat-1",
+        text: "Before tool.",
         attachments: undefined,
-        assistantId: 'assistant-1',
+        assistantId: "assistant-1",
       },
-      bearerToken: 'token',
+      bearerToken: "token",
     });
     expect(deliveryCalls[1]).toEqual({
-      callbackUrl: 'http://gateway/deliver/telegram',
+      callbackUrl: "http://gateway/deliver/telegram",
       payload: {
-        chatId: 'chat-1',
-        text: 'After tool.',
+        chatId: "chat-1",
+        text: "After tool.",
         attachments,
-        assistantId: 'assistant-1',
+        assistantId: "assistant-1",
       },
-      bearerToken: 'token',
+      bearerToken: "token",
     });
   });
 
-  it('falls back to rendered.text when no non-empty textSegments exist', async () => {
+  it("falls back to rendered.text when no non-empty textSegments exist", async () => {
     await deliverRenderedReplyViaCallback({
-      callbackUrl: 'http://gateway/deliver/sms',
-      chatId: 'chat-2',
-      textSegments: [' ', ''],
-      fallbackText: 'Fallback text',
+      callbackUrl: "http://gateway/deliver/sms",
+      chatId: "chat-2",
+      textSegments: [" ", ""],
+      fallbackText: "Fallback text",
       interSegmentDelayMs: 0,
     });
 
     expect(deliveryCalls).toHaveLength(1);
-    expect(deliveryCalls[0].payload.text).toBe('Fallback text');
+    expect(deliveryCalls[0].payload.text).toBe("Fallback text");
   });
 
-  it('uses rendered textSegments (tool boundaries) when delivering from conversation history', async () => {
+  it("uses rendered textSegments (tool boundaries) when delivering from conversation history", async () => {
     conversationMessages.push(
-      { id: 'msg-user', role: 'user', content: 'hi' },
-      { id: 'msg-assistant', role: 'assistant', content: '[{"type":"text","text":"ignored"}]' },
+      { id: "msg-user", role: "user", content: "hi" },
+      {
+        id: "msg-assistant",
+        role: "assistant",
+        content: '[{"type":"text","text":"ignored"}]',
+      },
     );
-    attachmentsByMessageId.set('msg-assistant', [{
-      id: 'att-2',
-      originalFilename: 'log.txt',
-      mimeType: 'text/plain',
-      sizeBytes: 42,
-      kind: 'uploaded',
-    }]);
+    attachmentsByMessageId.set("msg-assistant", [
+      {
+        id: "att-2",
+        originalFilename: "log.txt",
+        mimeType: "text/plain",
+        sizeBytes: 42,
+        kind: "uploaded",
+      },
+    ]);
     renderedHistoryContent = {
-      text: 'Before tool.After tool.',
-      textSegments: ['Before tool.', 'After tool.'],
+      text: "Before tool.After tool.",
+      textSegments: ["Before tool.", "After tool."],
       toolCalls: [],
       toolCallsBeforeText: false,
-      contentOrder: ['text:0', 'tool:0', 'text:1'],
+      contentOrder: ["text:0", "tool:0", "text:1"],
       surfaces: [],
     };
 
     await deliverReplyViaCallback(
-      'conv-1',
-      'chat-3',
-      'http://gateway/deliver/telegram',
-      'token',
-      'assistant-2',
+      "conv-1",
+      "chat-3",
+      "http://gateway/deliver/telegram",
+      "token",
+      "assistant-2",
     );
 
     expect(deliveryCalls).toHaveLength(2);
     expect(deliveryCalls[0].payload).toEqual({
-      chatId: 'chat-3',
-      text: 'Before tool.',
+      chatId: "chat-3",
+      text: "Before tool.",
       attachments: undefined,
-      assistantId: 'assistant-2',
+      assistantId: "assistant-2",
     });
     expect(deliveryCalls[1].payload).toEqual({
-      chatId: 'chat-3',
-      text: 'After tool.',
-      attachments: [{
-        id: 'att-2',
-        filename: 'log.txt',
-        mimeType: 'text/plain',
-        sizeBytes: 42,
-        kind: 'uploaded',
-      }],
-      assistantId: 'assistant-2',
+      chatId: "chat-3",
+      text: "After tool.",
+      attachments: [
+        {
+          id: "att-2",
+          filename: "log.txt",
+          mimeType: "text/plain",
+          sizeBytes: 42,
+          kind: "uploaded",
+        },
+      ],
+      assistantId: "assistant-2",
     });
   });
 
-  it('skips already-delivered segments when startFromSegment is set', async () => {
+  it("skips already-delivered segments when startFromSegment is set", async () => {
     await deliverRenderedReplyViaCallback({
-      callbackUrl: 'http://gateway/deliver/telegram',
-      chatId: 'chat-resume',
-      textSegments: ['Segment A.', 'Segment B.', 'Segment C.'],
+      callbackUrl: "http://gateway/deliver/telegram",
+      chatId: "chat-resume",
+      textSegments: ["Segment A.", "Segment B.", "Segment C."],
       interSegmentDelayMs: 0,
       startFromSegment: 1,
     });
 
     // Should only deliver segments B and C (indices 1 and 2)
     expect(deliveryCalls).toHaveLength(2);
-    expect(deliveryCalls[0].payload.text).toBe('Segment B.');
-    expect(deliveryCalls[1].payload.text).toBe('Segment C.');
+    expect(deliveryCalls[0].payload.text).toBe("Segment B.");
+    expect(deliveryCalls[1].payload.text).toBe("Segment C.");
   });
 
-  it('calls onSegmentDelivered after each successful segment', async () => {
+  it("calls onSegmentDelivered after each successful segment", async () => {
     const delivered: number[] = [];
 
     await deliverRenderedReplyViaCallback({
-      callbackUrl: 'http://gateway/deliver/telegram',
-      chatId: 'chat-progress',
-      textSegments: ['Part 1.', 'Part 2.', 'Part 3.'],
+      callbackUrl: "http://gateway/deliver/telegram",
+      chatId: "chat-progress",
+      textSegments: ["Part 1.", "Part 2.", "Part 3."],
       interSegmentDelayMs: 0,
       onSegmentDelivered: (count) => delivered.push(count),
     });
@@ -230,15 +259,15 @@ describe('channel-reply-delivery', () => {
     expect(deliveryCalls).toHaveLength(3);
   });
 
-  it('does not call onSegmentDelivered for a failing segment', async () => {
+  it("does not call onSegmentDelivered for a failing segment", async () => {
     const delivered: number[] = [];
     deliveryFailAtIndex = 2;
 
     try {
       await deliverRenderedReplyViaCallback({
-        callbackUrl: 'http://gateway/deliver/telegram',
-        chatId: 'chat-fail',
-        textSegments: ['Part 1.', 'Part 2.', 'Part 3.'],
+        callbackUrl: "http://gateway/deliver/telegram",
+        chatId: "chat-fail",
+        textSegments: ["Part 1.", "Part 2.", "Part 3."],
         interSegmentDelayMs: 0,
         onSegmentDelivered: (count) => delivered.push(count),
       });
@@ -251,16 +280,16 @@ describe('channel-reply-delivery', () => {
     expect(deliveryCalls).toHaveLength(2);
   });
 
-  it('resumes delivery after partial failure using startFromSegment', async () => {
+  it("resumes delivery after partial failure using startFromSegment", async () => {
     const delivered: number[] = [];
 
     // First attempt: fails on third segment (index 2)
     deliveryFailAtIndex = 2;
     try {
       await deliverRenderedReplyViaCallback({
-        callbackUrl: 'http://gateway/deliver/telegram',
-        chatId: 'chat-retry',
-        textSegments: ['Seg A.', 'Seg B.', 'Seg C.'],
+        callbackUrl: "http://gateway/deliver/telegram",
+        chatId: "chat-retry",
+        textSegments: ["Seg A.", "Seg B.", "Seg C."],
         interSegmentDelayMs: 0,
         onSegmentDelivered: (count) => delivered.push(count),
       });
@@ -278,9 +307,9 @@ describe('channel-reply-delivery', () => {
 
     // Retry: start from segment 2 (the last delivered count)
     await deliverRenderedReplyViaCallback({
-      callbackUrl: 'http://gateway/deliver/telegram',
-      chatId: 'chat-retry',
-      textSegments: ['Seg A.', 'Seg B.', 'Seg C.'],
+      callbackUrl: "http://gateway/deliver/telegram",
+      chatId: "chat-retry",
+      textSegments: ["Seg A.", "Seg B.", "Seg C."],
       interSegmentDelayMs: 0,
       startFromSegment: 2,
       onSegmentDelivered: (count) => delivered.push(count),
@@ -288,15 +317,15 @@ describe('channel-reply-delivery', () => {
 
     // Only segment C should be delivered
     expect(deliveryCalls).toHaveLength(1);
-    expect(deliveryCalls[0].payload.text).toBe('Seg C.');
+    expect(deliveryCalls[0].payload.text).toBe("Seg C.");
     expect(delivered).toEqual([3]);
   });
 
-  it('skips all segments when startFromSegment equals total count', async () => {
+  it("skips all segments when startFromSegment equals total count", async () => {
     await deliverRenderedReplyViaCallback({
-      callbackUrl: 'http://gateway/deliver/telegram',
-      chatId: 'chat-done',
-      textSegments: ['Done A.', 'Done B.'],
+      callbackUrl: "http://gateway/deliver/telegram",
+      chatId: "chat-done",
+      textSegments: ["Done A.", "Done B."],
       interSegmentDelayMs: 0,
       startFromSegment: 2,
     });
@@ -305,27 +334,27 @@ describe('channel-reply-delivery', () => {
     expect(deliveryCalls).toHaveLength(0);
   });
 
-  it('passes startFromSegment through deliverReplyViaCallback options', async () => {
+  it("passes startFromSegment through deliverReplyViaCallback options", async () => {
     conversationMessages.push(
-      { id: 'msg-u', role: 'user', content: 'hi' },
-      { id: 'msg-a', role: 'assistant', content: '"text"' },
+      { id: "msg-u", role: "user", content: "hi" },
+      { id: "msg-a", role: "assistant", content: '"text"' },
     );
     renderedHistoryContent = {
-      text: 'Alpha.Beta.Gamma.',
-      textSegments: ['Alpha.', 'Beta.', 'Gamma.'],
+      text: "Alpha.Beta.Gamma.",
+      textSegments: ["Alpha.", "Beta.", "Gamma."],
       toolCalls: [],
       toolCallsBeforeText: false,
-      contentOrder: ['text:0', 'tool:0', 'text:1', 'tool:1', 'text:2'],
+      contentOrder: ["text:0", "tool:0", "text:1", "tool:1", "text:2"],
       surfaces: [],
     };
 
     const delivered: number[] = [];
     await deliverReplyViaCallback(
-      'conv-resume',
-      'chat-resume',
-      'http://gateway/deliver/telegram',
-      'token',
-      'assistant-3',
+      "conv-resume",
+      "chat-resume",
+      "http://gateway/deliver/telegram",
+      "token",
+      "assistant-3",
       {
         startFromSegment: 1,
         onSegmentDelivered: (count) => delivered.push(count),
@@ -334,8 +363,8 @@ describe('channel-reply-delivery', () => {
 
     // Should skip 'Alpha.' and deliver 'Beta.' and 'Gamma.'
     expect(deliveryCalls).toHaveLength(2);
-    expect(deliveryCalls[0].payload.text).toBe('Beta.');
-    expect(deliveryCalls[1].payload.text).toBe('Gamma.');
+    expect(deliveryCalls[0].payload.text).toBe("Beta.");
+    expect(deliveryCalls[1].payload.text).toBe("Gamma.");
     expect(delivered).toEqual([2, 3]);
   });
 });