@vellumai/assistant 0.11.2 → 0.11.3-dev.202608080427.92f668a

package/src/__tests__/attachments.test.ts

@@ -88,8 +88,8 @@ describe("attachmentsToReferenceBlocks", () => {
 // ---------------------------------------------------------------------------
 
 describe("attachmentsToContentBlocks", () => {
-  test("creates image content block for image/jpeg", () => {
-    const blocks = attachmentsToContentBlocks([
+  test("creates image content block for image/jpeg", async () => {
+    const blocks = await attachmentsToContentBlocks([
       { filename: "photo.jpg", mimeType: "image/jpeg", data: "base64data" },
     ]);
 
@@ -104,8 +104,8 @@ describe("attachmentsToContentBlocks", () => {
     expect(block.source.data).toBe("base64data");
   });
 
-  test("creates image content block for image/png", () => {
-    const blocks = attachmentsToContentBlocks([
+  test("creates image content block for image/png", async () => {
+    const blocks = await attachmentsToContentBlocks([
       { filename: "screenshot.png", mimeType: "image/png", data: "pngdata" },
     ]);
 
@@ -113,8 +113,8 @@ describe("attachmentsToContentBlocks", () => {
     expect(blocks[0].type).toBe("image");
   });
 
-  test("creates image content block for image/webp", () => {
-    const blocks = attachmentsToContentBlocks([
+  test("creates image content block for image/webp", async () => {
+    const blocks = await attachmentsToContentBlocks([
       { filename: "sticker.webp", mimeType: "image/webp", data: "webpdata" },
     ]);
 
@@ -122,8 +122,8 @@ describe("attachmentsToContentBlocks", () => {
     expect(blocks[0].type).toBe("image");
   });
 
-  test("creates file content block for non-image mime types", () => {
-    const blocks = attachmentsToContentBlocks([
+  test("creates file content block for non-image mime types", async () => {
+    const blocks = await attachmentsToContentBlocks([
       { filename: "doc.pdf", mimeType: "application/pdf", data: "pdfdata" },
     ]);
 
@@ -137,8 +137,8 @@ describe("attachmentsToContentBlocks", () => {
     expect(block.source.media_type).toBe("application/pdf");
   });
 
-  test("handles multiple attachments including mixed types", () => {
-    const blocks = attachmentsToContentBlocks([
+  test("handles multiple attachments including mixed types", async () => {
+    const blocks = await attachmentsToContentBlocks([
       { filename: "photo.jpg", mimeType: "image/jpeg", data: "imgdata" },
       { filename: "notes.txt", mimeType: "text/plain", data: "txtdata" },
     ]);
@@ -148,8 +148,8 @@ describe("attachmentsToContentBlocks", () => {
     expect(blocks[1].type).toBe("file");
   });
 
-  test("returns empty array for no attachments", () => {
-    const blocks = attachmentsToContentBlocks([]);
+  test("returns empty array for no attachments", async () => {
+    const blocks = await attachmentsToContentBlocks([]);
     expect(blocks).toHaveLength(0);
   });
 });
@@ -159,8 +159,8 @@ describe("attachmentsToContentBlocks", () => {
 // ---------------------------------------------------------------------------
 
 describe("createUserMessage with image attachments", () => {
-  test("includes both text and image blocks", () => {
-    const msg = createUserMessage("what is this?", [
+  test("includes both text and image blocks", async () => {
+    const msg = await createUserMessage("what is this?", [
       { filename: "photo.jpg", mimeType: "image/jpeg", data: "base64img" },
     ]);
 
@@ -173,8 +173,8 @@ describe("createUserMessage with image attachments", () => {
     expect(msg.content[1].type).toBe("image");
   });
 
-  test("includes only image block when text is empty", () => {
-    const msg = createUserMessage("", [
+  test("includes only image block when text is empty", async () => {
+    const msg = await createUserMessage("", [
       { filename: "photo.jpg", mimeType: "image/jpeg", data: "base64img" },
     ]);
 
@@ -183,8 +183,8 @@ describe("createUserMessage with image attachments", () => {
     expect(msg.content[0].type).toBe("image");
   });
 
-  test("includes only image block when text is whitespace", () => {
-    const msg = createUserMessage("   ", [
+  test("includes only image block when text is whitespace", async () => {
+    const msg = await createUserMessage("   ", [
       { filename: "photo.jpg", mimeType: "image/jpeg", data: "base64img" },
     ]);
 
@@ -193,8 +193,8 @@ describe("createUserMessage with image attachments", () => {
     expect(msg.content[0].type).toBe("image");
   });
 
-  test("includes multiple image blocks", () => {
-    const msg = createUserMessage("compare these", [
+  test("includes multiple image blocks", async () => {
+    const msg = await createUserMessage("compare these", [
       { filename: "a.jpg", mimeType: "image/jpeg", data: "img1" },
       { filename: "b.png", mimeType: "image/png", data: "img2" },
     ]);
@@ -206,9 +206,9 @@ describe("createUserMessage with image attachments", () => {
     expect(msg.content[2].type).toBe("image");
   });
 
-  test("preserves base64 data in image content block", () => {
+  test("preserves base64 data in image content block", async () => {
     const base64 = "dGVzdC1pbWFnZS1kYXRh";
-    const msg = createUserMessage("test", [
+    const msg = await createUserMessage("test", [
       { filename: "photo.jpg", mimeType: "image/jpeg", data: base64 },
     ]);
 
@@ -227,7 +227,7 @@ describe("createUserMessage with image attachments", () => {
 // ---------------------------------------------------------------------------
 
 describe("enrichMessageWithSourcePaths", () => {
-  test("appends a source path annotation for images with filePath", () => {
+  test("appends a source path annotation for images with filePath", async () => {
     const attachments = [
       {
         filename: "photo.jpg",
@@ -236,7 +236,7 @@ describe("enrichMessageWithSourcePaths", () => {
         filePath: "/Users/me/Desktop/photo.jpg",
       },
     ];
-    const original = createUserMessage("what is this?", attachments);
+    const original = await createUserMessage("what is this?", attachments);
     const enriched = enrichMessageWithSourcePaths(original, attachments);
 
     expect(enriched).not.toBe(original);
@@ -249,7 +249,7 @@ describe("enrichMessageWithSourcePaths", () => {
     );
   });
 
-  test("returns the original message (same reference) when no images have filePath", () => {
+  test("returns the original message (same reference) when no images have filePath", async () => {
     const attachments = [
       {
         filename: "photo.jpg",
@@ -257,13 +257,13 @@ describe("enrichMessageWithSourcePaths", () => {
         data: "base64img",
       },
     ];
-    const original = createUserMessage("what is this?", attachments);
+    const original = await createUserMessage("what is this?", attachments);
     const result = enrichMessageWithSourcePaths(original, attachments);
 
     expect(result).toBe(original);
   });
 
-  test("skips non-image attachments with filePath", () => {
+  test("skips non-image attachments with filePath", async () => {
     const attachments = [
       {
         filename: "doc.pdf",
@@ -272,14 +272,14 @@ describe("enrichMessageWithSourcePaths", () => {
         filePath: "/Users/me/Documents/doc.pdf",
       },
     ];
-    const original = createUserMessage("review this", attachments);
+    const original = await createUserMessage("review this", attachments);
     const result = enrichMessageWithSourcePaths(original, attachments);
 
     // Non-image attachments are not annotated, so we get back the same ref
     expect(result).toBe(original);
   });
 
-  test("handles multiple images with file paths", () => {
+  test("handles multiple images with file paths", async () => {
     const attachments = [
       {
         filename: "a.jpg",
@@ -294,7 +294,7 @@ describe("enrichMessageWithSourcePaths", () => {
         filePath: "/path/to/b.png",
       },
     ];
-    const original = createUserMessage("compare", attachments);
+    const original = await createUserMessage("compare", attachments);
     const enriched = enrichMessageWithSourcePaths(original, attachments);
 
     expect(enriched).not.toBe(original);
@@ -307,7 +307,7 @@ describe("enrichMessageWithSourcePaths", () => {
     );
   });
 
-  test("only annotates images that have filePath, skips those without", () => {
+  test("only annotates images that have filePath, skips those without", async () => {
     const attachments = [
       {
         filename: "a.jpg",
@@ -322,7 +322,7 @@ describe("enrichMessageWithSourcePaths", () => {
         // no filePath — e.g. pasted screenshot
       },
     ];
-    const original = createUserMessage("compare", attachments);
+    const original = await createUserMessage("compare", attachments);
     const enriched = enrichMessageWithSourcePaths(original, attachments);
 
     expect(enriched).not.toBe(original);
@@ -332,7 +332,7 @@ describe("enrichMessageWithSourcePaths", () => {
     expect(annotation.text).toBe("[Attached image source: /path/to/a.jpg]");
   });
 
-  test("annotates non-image attachments that have storedPath", () => {
+  test("annotates non-image attachments that have storedPath", async () => {
     const attachments = [
       {
         filename: "report.pdf",
@@ -342,7 +342,7 @@ describe("enrichMessageWithSourcePaths", () => {
         storedPath: "/conv/attachments/report-2.pdf",
       },
     ];
-    const original = createUserMessage("review my edits", attachments);
+    const original = await createUserMessage("review my edits", attachments);
     const enriched = enrichMessageWithSourcePaths(original, attachments);
 
     expect(enriched).not.toBe(original);
@@ -355,7 +355,7 @@ describe("enrichMessageWithSourcePaths", () => {
     );
   });
 
-  test("emits image source lines before stored path lines in one block", () => {
+  test("emits image source lines before stored path lines in one block", async () => {
     const attachments = [
       {
         filename: "data.csv",
@@ -371,7 +371,7 @@ describe("enrichMessageWithSourcePaths", () => {
         storedPath: "/conv/attachments/photo.jpg",
       },
     ];
-    const original = createUserMessage("compare", attachments);
+    const original = await createUserMessage("compare", attachments);
     const enriched = enrichMessageWithSourcePaths(original, attachments);
 
     const annotation = enriched.content.at(-1) as {

package/src/__tests__/background-workers-disk-pressure.test.ts

@@ -61,7 +61,7 @@ mock.module("../persistence/conversation-crud.js", () => ({
   getConversationPersistedSeq: () => null,
   addMessage: mock(() => ({ id: "msg-1" })),
   archiveConversation: mock(() => true),
-  batchSetDisplayOrders: mock(() => {}),
+  batchSetConversationPlacement: mock(() => {}),
   createConversation: (opts: { conversationType: string }) => {
     createdConversations.push(opts);
     return { id: "conv-1", ...opts };

package/src/__tests__/call-controller.test.ts

@@ -377,6 +377,8 @@ function setupController(
     requiresPcmAudio?: boolean;
     /** Simulate a transport that gates teardown on playback drain. */
     awaitPlaybackDrained?: () => Promise<void>;
+    /** Synthesis-language resolver, as the media-stream server wires it. */
+    resolveSynthesisLanguage?: () => string | undefined;
   },
 ) {
   ensureConversation("conv-ctrl-test");
@@ -400,6 +402,7 @@ function setupController(
   const controller = new CallController(session.id, transport, task ?? null, {
     assistantId: opts?.assistantId,
     trustContext: opts?.trustContext,
+    resolveSynthesisLanguage: opts?.resolveSynthesisLanguage,
   });
   return { session, relay: transport, controller };
 }
@@ -3470,6 +3473,123 @@ describe("call-controller", () => {
     controller.destroy();
   });
 
+  test("synthesized provider: the resolved language rides every segment's synthesis request", async () => {
+    const requestLanguages: Array<string | undefined> = [];
+    registerFishAudioSegmentRecorder({
+      onSynthesizeStream: async (_text, request) => {
+        requestLanguages.push(request.language);
+      },
+    });
+    mockStartVoiceTurn.mockImplementation(
+      createMockVoiceTurn(["Hola desde aqui. ", "Segunda frase."]),
+    );
+    const { controller } = setupController(undefined, {
+      resolveSynthesisLanguage: () => "es",
+    });
+
+    await controller.handleCallerUtterance("Hola");
+
+    expect(requestLanguages).toEqual(["es", "es"]);
+
+    controller.destroy();
+  });
+
+  test("synthesized provider: no language on the request when nothing resolves", async () => {
+    const requestLanguages: Array<string | undefined> = [];
+    registerFishAudioSegmentRecorder({
+      onSynthesizeStream: async (_text, request) => {
+        requestLanguages.push(request.language);
+      },
+    });
+    mockStartVoiceTurn.mockImplementation(
+      createMockVoiceTurn(["Hello from here."]),
+    );
+    // Default resolver + default config (multilingual STT pin): no hint.
+    const { controller } = setupController();
+
+    await controller.handleCallerUtterance("Hi");
+
+    expect(requestLanguages).toEqual([undefined]);
+
+    controller.destroy();
+  });
+
+  function registerDeepgramRequestRecorder(): {
+    requests: Array<{ voiceId?: string; language?: string }>;
+  } {
+    const cfg = loadConfig();
+    cfg.services.tts.provider = "deepgram";
+
+    _resetTtsProviderOverridesForTests();
+    const requests: Array<{ voiceId?: string; language?: string }> = [];
+    const deepgramRecorder: TtsProvider = {
+      id: "deepgram",
+      capabilities: {
+        supportsStreaming: false,
+        supportedFormats: ["mp3", "wav", "opus"],
+      },
+      async synthesize(request) {
+        requests.push({
+          voiceId: request.voiceId,
+          language: request.language,
+        });
+        return { audio: Buffer.from("audio"), contentType: "audio/mpeg" };
+      },
+    };
+    _setTtsProviderForTests(deepgramRecorder);
+    return { requests };
+  }
+
+  test("synthesized provider: a configured languageVoices entry for the call language rides the request as voiceId", async () => {
+    const cfg = loadConfig();
+    cfg.services.tts.providers.deepgram.languageVoices = {
+      hi: "aura-2-hindi-voice",
+    };
+    try {
+      const { requests } = registerDeepgramRequestRecorder();
+      mockStartVoiceTurn.mockImplementation(
+        createMockVoiceTurn(["Namaste doston."]),
+      );
+      const { controller } = setupController(undefined, {
+        resolveSynthesisLanguage: () => "hi",
+      });
+
+      await controller.handleCallerUtterance("Namaste");
+
+      expect(requests).toEqual([
+        { voiceId: "aura-2-hindi-voice", language: "hi" },
+      ]);
+
+      controller.destroy();
+    } finally {
+      delete cfg.services.tts.providers.deepgram.languageVoices;
+    }
+  });
+
+  test("synthesized provider: no voiceId when languageVoices has no entry for the call language", async () => {
+    const cfg = loadConfig();
+    cfg.services.tts.providers.deepgram.languageVoices = {
+      hi: "aura-2-hindi-voice",
+    };
+    try {
+      const { requests } = registerDeepgramRequestRecorder();
+      mockStartVoiceTurn.mockImplementation(
+        createMockVoiceTurn(["Hola desde aqui."]),
+      );
+      const { controller } = setupController(undefined, {
+        resolveSynthesisLanguage: () => "es",
+      });
+
+      await controller.handleCallerUtterance("Hola");
+
+      expect(requests).toEqual([{ voiceId: undefined, language: "es" }]);
+
+      controller.destroy();
+    } finally {
+      delete cfg.services.tts.providers.deepgram.languageVoices;
+    }
+  });
+
   test("synthesized provider: segments synthesize serially in order even when the first is slow", async () => {
     const events: string[] = [];
     registerFishAudioSegmentRecorder({

package/src/__tests__/call-start-guardian-guard.test.ts

@@ -40,10 +40,24 @@ const realGatewaySessionsModule = {
 };
 mock.module("../channels/gateway-verification-sessions.js", () => ({
   ...realGatewaySessionsModule,
-  findActiveSession: async (channel: string) =>
-    findActiveSessionMockActive
-      ? activeVoiceSession
-      : realGatewaySessionsModule.findActiveSession(channel),
+  // Honours the caller's filter: the guard asks for the number it is about
+  // to dial, so a session for a different number must read as absent.
+  findActiveSession: async (
+    channel: string,
+    filter?: { expectedExternalUserId?: string },
+  ) => {
+    if (!findActiveSessionMockActive) {
+      return realGatewaySessionsModule.findActiveSession(channel, filter);
+    }
+    const wanted = filter?.expectedExternalUserId;
+    if (
+      wanted !== undefined &&
+      activeVoiceSession?.expectedPhoneE164 !== wanted
+    ) {
+      return null;
+    }
+    return activeVoiceSession;
+  },
 }));
 
 const { executeCallStart } = await import("../tools/calls/call-start.js");

package/src/__tests__/canned-reply-release.test.ts

@@ -0,0 +1,86 @@
+/**
+ * The canned-reply routes (canned first greeting, unknown slash command) hold
+ * the processing lock themselves and release it from a deferred callback that
+ * also publishes their client event burst. That release is the only one those
+ * turns get: no agent loop runs, so a throw escaping the burst would latch the
+ * conversation "processing" for the life of the daemon and queue every later
+ * send behind an idle conversation.
+ */
+import { describe, expect, test } from "bun:test";
+
+import type { QueueDrainReason } from "../daemon/conversation-queue-manager.js";
+import { scheduleCannedReplyRelease } from "../runtime/routes/canned-reply-release.js";
+
+function makeConversation() {
+  let processing = true;
+  const drainOrigins: string[] = [];
+  return {
+    isProcessing: () => processing,
+    drainOrigins,
+    target: {
+      setProcessing: (value: boolean) => {
+        processing = value;
+      },
+      kickDrainQueue: (_reason?: QueueDrainReason, origin?: string) => {
+        drainOrigins.push(origin ?? "");
+        return Promise.resolve();
+      },
+    },
+  };
+}
+
+/** Let the scheduled `setTimeout(..., 0)` callback run. */
+function nextTick(): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, 0));
+}
+
+describe("scheduleCannedReplyRelease", () => {
+  test("releases and drains after the deferred event burst", async () => {
+    const conversation = makeConversation();
+    const order: string[] = [];
+
+    scheduleCannedReplyRelease({
+      conversation: {
+        setProcessing: (value: boolean) => {
+          order.push("release");
+          conversation.target.setProcessing(value);
+        },
+        kickDrainQueue: conversation.target.kickDrainQueue,
+      },
+      origin: "canned_greeting",
+      emit: () => {
+        order.push("emit");
+      },
+      afterRelease: () => {
+        order.push("after");
+      },
+    });
+
+    // Nothing runs synchronously: the HTTP response has to reach the client
+    // before its events do.
+    expect(order).toEqual([]);
+
+    await nextTick();
+
+    expect(order).toEqual(["emit", "release", "after"]);
+    expect(conversation.isProcessing()).toBe(false);
+    expect(conversation.drainOrigins).toEqual(["canned_greeting"]);
+  });
+
+  test("still releases and drains when a broadcast throws", async () => {
+    const conversation = makeConversation();
+
+    scheduleCannedReplyRelease({
+      conversation: conversation.target,
+      origin: "slash_command",
+      emit: () => {
+        throw new Error("broadcast exploded");
+      },
+    });
+
+    await nextTick();
+
+    expect(conversation.isProcessing()).toBe(false);
+    expect(conversation.drainOrigins).toEqual(["slash_command"]);
+  });
+});

package/src/__tests__/channel-availability-routes.test.ts

@@ -57,6 +57,8 @@ const handler = ROUTES[0]!.handler;
 
 interface ChannelEntry {
   id: string;
+  /** `default` here, `plugin:<name>` for a channel a plugin brings. */
+  source: string;
   label: string;
   subtitle: string;
   icon: string;
@@ -173,10 +175,21 @@ describe("channels/available", () => {
     for (const channel of result.channels) {
       const expected = (CHANNEL_METADATA as any)[channel.id];
       expect(expected).toBeDefined();
-      expect(channel).toEqual(expected);
+      // Plus `source`, which the metadata does not carry: it says who
+      // contributes the row, and every row here comes from the assistant.
+      expect(channel).toEqual({ ...expected, source: "default" });
     }
   });
 
+  test("marks every channel the assistant ships as its own", async () => {
+    // The base list is what a client compares a plugin-contributed row
+    // against, so the marker has to be present rather than implied by an
+    // absent field.
+    const result = (await handler({})) as HandlerResult;
+
+    expect(result.channels.every((c) => c.source === "default")).toBe(true);
+  });
+
   test("email metadata: not verification-capable, mail icon", async () => {
     mockEmailAddressesResponse = {
       ok: true,