@vellumai/assistant 0.6.3 → 0.6.4

package/src/__tests__/media-turn-detector.test.ts

@@ -0,0 +1,440 @@
+import { afterEach, beforeEach, describe, expect, jest, test } from "bun:test";
+
+import { MediaTurnDetector } from "../calls/media-turn-detector.js";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Advance fake timers by `ms` milliseconds. Uses Bun's `jest.advanceTimersByTime`.
+ */
+function advance(ms: number): void {
+  jest.advanceTimersByTime(ms);
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("MediaTurnDetector", () => {
+  beforeEach(() => {
+    jest.useFakeTimers();
+  });
+
+  afterEach(() => {
+    jest.useRealTimers();
+  });
+
+  // ── Basic lifecycle ──────────────────────────────────────────────
+
+  test("starts inactive", () => {
+    const detector = new MediaTurnDetector();
+    expect(detector.isActive).toBe(false);
+    detector.dispose();
+  });
+
+  test("transitions to active on first chunk", () => {
+    const detector = new MediaTurnDetector();
+    detector.onMediaChunk();
+    expect(detector.isActive).toBe(true);
+    detector.dispose();
+  });
+
+  // ── Silence detection ────────────────────────────────────────────
+
+  test("fires onTurnEnd with 'silence' after silence threshold", () => {
+    const onTurnStart = jest.fn();
+    const onTurnEnd = jest.fn();
+
+    const detector = new MediaTurnDetector(
+      { silenceThresholdMs: 500 },
+      { onTurnStart, onTurnEnd },
+    );
+
+    detector.onMediaChunk();
+    expect(onTurnStart).toHaveBeenCalledTimes(1);
+    expect(detector.isActive).toBe(true);
+
+    // Advance past the silence threshold
+    advance(600);
+
+    expect(onTurnEnd).toHaveBeenCalledTimes(1);
+    expect(onTurnEnd).toHaveBeenCalledWith("silence", expect.any(Number));
+    expect(detector.isActive).toBe(false);
+
+    detector.dispose();
+  });
+
+  test("resets silence timer on subsequent chunks", () => {
+    const onTurnEnd = jest.fn();
+
+    const detector = new MediaTurnDetector(
+      { silenceThresholdMs: 500 },
+      { onTurnEnd },
+    );
+
+    detector.onMediaChunk();
+
+    // 300ms in — silence timer has NOT fired yet
+    advance(300);
+    expect(onTurnEnd).not.toHaveBeenCalled();
+
+    // New chunk resets the 500ms silence timer
+    detector.onMediaChunk();
+
+    // Another 300ms — still within the reset window
+    advance(300);
+    expect(onTurnEnd).not.toHaveBeenCalled();
+
+    // 250ms more (550ms since last chunk) — past threshold
+    advance(250);
+    expect(onTurnEnd).toHaveBeenCalledTimes(1);
+    expect(onTurnEnd).toHaveBeenCalledWith("silence", expect.any(Number));
+
+    detector.dispose();
+  });
+
+  // ── Max duration ─────────────────────────────────────────────────
+
+  test("fires onTurnEnd with 'max-duration' when hard cap is reached", () => {
+    const onTurnEnd = jest.fn();
+
+    const detector = new MediaTurnDetector(
+      { silenceThresholdMs: 500, maxTurnDurationMs: 2000 },
+      { onTurnEnd },
+    );
+
+    detector.onMediaChunk();
+
+    // Keep feeding chunks so the silence timer never fires
+    for (let i = 0; i < 8; i++) {
+      advance(200);
+      detector.onMediaChunk();
+    }
+
+    // At 1600ms, still active. Advance to 2000ms.
+    advance(400);
+
+    expect(onTurnEnd).toHaveBeenCalledTimes(1);
+    expect(onTurnEnd).toHaveBeenCalledWith("max-duration", expect.any(Number));
+    expect(detector.isActive).toBe(false);
+
+    detector.dispose();
+  });
+
+  // ── Turn restart ─────────────────────────────────────────────────
+
+  test("can start a new turn after silence ends the previous one", () => {
+    const onTurnStart = jest.fn();
+    const onTurnEnd = jest.fn();
+
+    const detector = new MediaTurnDetector(
+      { silenceThresholdMs: 500 },
+      { onTurnStart, onTurnEnd },
+    );
+
+    // First turn
+    detector.onMediaChunk();
+    expect(onTurnStart).toHaveBeenCalledTimes(1);
+    advance(600);
+    expect(onTurnEnd).toHaveBeenCalledTimes(1);
+    expect(detector.isActive).toBe(false);
+
+    // Second turn
+    detector.onMediaChunk();
+    expect(onTurnStart).toHaveBeenCalledTimes(2);
+    expect(detector.isActive).toBe(true);
+
+    advance(600);
+    expect(onTurnEnd).toHaveBeenCalledTimes(2);
+
+    detector.dispose();
+  });
+
+  // ── forceEnd ─────────────────────────────────────────────────────
+
+  test("forceEnd ends the current turn immediately", () => {
+    const onTurnEnd = jest.fn();
+
+    const detector = new MediaTurnDetector(
+      { silenceThresholdMs: 500 },
+      { onTurnEnd },
+    );
+
+    detector.onMediaChunk();
+    expect(detector.isActive).toBe(true);
+
+    detector.forceEnd();
+    expect(onTurnEnd).toHaveBeenCalledTimes(1);
+    expect(onTurnEnd).toHaveBeenCalledWith("silence", expect.any(Number));
+    expect(detector.isActive).toBe(false);
+
+    detector.dispose();
+  });
+
+  test("forceEnd is a no-op when inactive", () => {
+    const onTurnEnd = jest.fn();
+
+    const detector = new MediaTurnDetector(
+      { silenceThresholdMs: 500 },
+      { onTurnEnd },
+    );
+
+    detector.forceEnd();
+    expect(onTurnEnd).not.toHaveBeenCalled();
+    expect(detector.isActive).toBe(false);
+
+    detector.dispose();
+  });
+
+  // ── dispose ──────────────────────────────────────────────────────
+
+  test("dispose prevents further callbacks", () => {
+    const onTurnStart = jest.fn();
+    const onTurnEnd = jest.fn();
+
+    const detector = new MediaTurnDetector(
+      { silenceThresholdMs: 500 },
+      { onTurnStart, onTurnEnd },
+    );
+
+    detector.onMediaChunk();
+    expect(onTurnStart).toHaveBeenCalledTimes(1);
+
+    detector.dispose();
+
+    // Silence timer should have been cleared — advancing should not
+    // trigger onTurnEnd.
+    advance(1000);
+    expect(onTurnEnd).not.toHaveBeenCalled();
+
+    // Further chunks should be ignored.
+    detector.onMediaChunk();
+    expect(onTurnStart).toHaveBeenCalledTimes(1);
+  });
+
+  test("dispose + forceEnd is a no-op", () => {
+    const onTurnEnd = jest.fn();
+
+    const detector = new MediaTurnDetector(
+      { silenceThresholdMs: 500 },
+      { onTurnEnd },
+    );
+
+    detector.onMediaChunk();
+    detector.dispose();
+    detector.forceEnd();
+    expect(onTurnEnd).not.toHaveBeenCalled();
+  });
+
+  // ── Default config ───────────────────────────────────────────────
+
+  test("uses default thresholds when config is omitted", () => {
+    const onTurnEnd = jest.fn();
+    const detector = new MediaTurnDetector({}, { onTurnEnd });
+
+    detector.onMediaChunk();
+
+    // Default silence threshold is 800ms
+    advance(700);
+    expect(onTurnEnd).not.toHaveBeenCalled();
+    advance(200);
+    expect(onTurnEnd).toHaveBeenCalledTimes(1);
+
+    detector.dispose();
+  });
+
+  // ── onTurnStart only fires once per turn ─────────────────────────
+
+  test("onTurnStart fires only once even with many chunks", () => {
+    const onTurnStart = jest.fn();
+    const detector = new MediaTurnDetector(
+      { silenceThresholdMs: 500 },
+      { onTurnStart },
+    );
+
+    detector.onMediaChunk();
+    detector.onMediaChunk();
+    detector.onMediaChunk();
+    detector.onMediaChunk();
+
+    expect(onTurnStart).toHaveBeenCalledTimes(1);
+
+    detector.dispose();
+  });
+
+  // ── Speech-aware segmentation ─────────────────────────────────────
+
+  describe("speech-aware segmentation", () => {
+    test("continuous chunk flow with speech->silence transition ends the turn", () => {
+      const onTurnStart = jest.fn();
+      const onTurnEnd = jest.fn();
+
+      const detector = new MediaTurnDetector(
+        { silenceThresholdMs: 500 },
+        { onTurnStart, onTurnEnd },
+      );
+
+      // Speech chunks — resets silence timer on each
+      detector.onMediaChunk(true);
+      expect(onTurnStart).toHaveBeenCalledTimes(1);
+
+      advance(100);
+      detector.onMediaChunk(true);
+      advance(100);
+      detector.onMediaChunk(true);
+
+      // Transition to silence — continuous silent chunks should NOT
+      // reset the silence timer, so the turn ends after the threshold.
+      advance(100);
+      detector.onMediaChunk(false);
+      advance(100);
+      detector.onMediaChunk(false);
+      advance(100);
+      detector.onMediaChunk(false);
+
+      // Not yet past threshold from last speech chunk (300ms of silence
+      // plus whatever the timer started at when silence began)
+      expect(onTurnEnd).not.toHaveBeenCalled();
+
+      // Advance past the silence threshold from the last speech chunk
+      advance(500);
+
+      expect(onTurnEnd).toHaveBeenCalledTimes(1);
+      expect(onTurnEnd).toHaveBeenCalledWith("silence", expect.any(Number));
+      expect(detector.isActive).toBe(false);
+
+      detector.dispose();
+    });
+
+    test("no-speech continuous noise/silence does not start a turn", () => {
+      const onTurnStart = jest.fn();
+      const onTurnEnd = jest.fn();
+
+      const detector = new MediaTurnDetector(
+        { silenceThresholdMs: 500 },
+        { onTurnStart, onTurnEnd },
+      );
+
+      // Send many chunks with no speech — turn should never start
+      for (let i = 0; i < 20; i++) {
+        detector.onMediaChunk(false);
+        advance(50);
+      }
+
+      expect(onTurnStart).not.toHaveBeenCalled();
+      expect(onTurnEnd).not.toHaveBeenCalled();
+      expect(detector.isActive).toBe(false);
+
+      detector.dispose();
+    });
+
+    test("max-duration fallback still fires with continuous speech", () => {
+      const onTurnEnd = jest.fn();
+
+      const detector = new MediaTurnDetector(
+        { silenceThresholdMs: 500, maxTurnDurationMs: 2000 },
+        { onTurnEnd },
+      );
+
+      // Continuous speech chunks — silence timer keeps resetting
+      detector.onMediaChunk(true);
+      for (let i = 0; i < 10; i++) {
+        advance(180);
+        detector.onMediaChunk(true);
+      }
+
+      // At ~1800ms. Advance to 2000ms to hit max-duration.
+      advance(200);
+
+      expect(onTurnEnd).toHaveBeenCalledTimes(1);
+      expect(onTurnEnd).toHaveBeenCalledWith(
+        "max-duration",
+        expect.any(Number),
+      );
+      expect(detector.isActive).toBe(false);
+
+      detector.dispose();
+    });
+
+    test("silent chunks during active turn do not reset the silence timer", () => {
+      const onTurnEnd = jest.fn();
+
+      const detector = new MediaTurnDetector(
+        { silenceThresholdMs: 500 },
+        { onTurnEnd },
+      );
+
+      // Start with speech
+      detector.onMediaChunk(true);
+
+      // Advance 200ms, then send silent chunks — they should NOT
+      // extend the turn by resetting the timer.
+      advance(200);
+      detector.onMediaChunk(false);
+      advance(100);
+      detector.onMediaChunk(false);
+      advance(100);
+      detector.onMediaChunk(false);
+
+      // Silence timer started from the last speech chunk. At 500ms
+      // from that point, the turn should end.
+      advance(200); // 200+100+100+200 = 600ms since last speech
+
+      expect(onTurnEnd).toHaveBeenCalledTimes(1);
+      expect(onTurnEnd).toHaveBeenCalledWith("silence", expect.any(Number));
+
+      detector.dispose();
+    });
+
+    test("speech resuming during silence countdown resets the timer", () => {
+      const onTurnEnd = jest.fn();
+
+      const detector = new MediaTurnDetector(
+        { silenceThresholdMs: 500 },
+        { onTurnEnd },
+      );
+
+      // Speech starts
+      detector.onMediaChunk(true);
+
+      // 300ms of silence
+      advance(300);
+      detector.onMediaChunk(false);
+
+      // Speech resumes — resets silence timer
+      advance(100);
+      detector.onMediaChunk(true);
+
+      // Timer reset: another 500ms must pass
+      advance(400);
+      expect(onTurnEnd).not.toHaveBeenCalled();
+
+      advance(200);
+      expect(onTurnEnd).toHaveBeenCalledTimes(1);
+
+      detector.dispose();
+    });
+
+    test("backwards compatibility: onMediaChunk without hasSpeech argument defaults to true", () => {
+      const onTurnStart = jest.fn();
+      const onTurnEnd = jest.fn();
+
+      const detector = new MediaTurnDetector(
+        { silenceThresholdMs: 500 },
+        { onTurnStart, onTurnEnd },
+      );
+
+      // Call without argument — defaults to hasSpeech=true
+      detector.onMediaChunk();
+      expect(onTurnStart).toHaveBeenCalledTimes(1);
+      expect(detector.isActive).toBe(true);
+
+      advance(600);
+      expect(onTurnEnd).toHaveBeenCalledTimes(1);
+
+      detector.dispose();
+    });
+  });
+});

package/src/__tests__/message-queue.test.ts

@@ -0,0 +1,125 @@
+import { describe, expect, test } from "bun:test";
+
+import {
+  DEFAULT_MAX_QUEUE_BYTES,
+  MessageQueue,
+  type QueuedMessage,
+} from "../daemon/conversation-queue-manager.js";
+
+function makeItem(content: string, requestId = "r"): QueuedMessage {
+  return {
+    content,
+    attachments: [],
+    requestId,
+    onEvent: () => {},
+    sentAt: Date.now(),
+  };
+}
+
+describe("MessageQueue.peek", () => {
+  test("peek(0) on empty queue returns undefined", () => {
+    const q = new MessageQueue();
+    expect(q.peek(0)).toBeUndefined();
+  });
+
+  test("peek(0) on non-empty queue returns head without mutating length or totalBytes", () => {
+    const q = new MessageQueue();
+    q.push(makeItem("first", "r1"));
+    q.push(makeItem("second", "r2"));
+
+    const lengthBefore = q.length;
+    const bytesBefore = q.totalBytes;
+
+    const head = q.peek(0);
+    expect(head).toBeDefined();
+    expect(head?.requestId).toBe("r1");
+    expect(head?.content).toBe("first");
+
+    expect(q.length).toBe(lengthBefore);
+    expect(q.totalBytes).toBe(bytesBefore);
+  });
+
+  test("peek(2) returns the third item; peek(99) returns undefined", () => {
+    const q = new MessageQueue();
+    q.push(makeItem("a", "r1"));
+    q.push(makeItem("b", "r2"));
+    q.push(makeItem("c", "r3"));
+
+    expect(q.peek(2)?.requestId).toBe("r3");
+    expect(q.peek(99)).toBeUndefined();
+  });
+});
+
+describe("MessageQueue.shiftN", () => {
+  test("shiftN(0) returns [] and does not mutate", () => {
+    const q = new MessageQueue();
+    q.push(makeItem("a", "r1"));
+    q.push(makeItem("b", "r2"));
+
+    const lengthBefore = q.length;
+    const bytesBefore = q.totalBytes;
+
+    const popped = q.shiftN(0);
+    expect(popped).toEqual([]);
+    expect(q.length).toBe(lengthBefore);
+    expect(q.totalBytes).toBe(bytesBefore);
+  });
+
+  test("shiftN(2) on a 3-item queue returns the first two in FIFO order; length becomes 1; totalBytes matches remaining", () => {
+    const q = new MessageQueue();
+    q.push(makeItem("a", "r1"));
+    q.push(makeItem("b", "r2"));
+    q.push(makeItem("c", "r3"));
+
+    // Capture the remaining-item bytes by draining a fresh queue with just "c".
+    const reference = new MessageQueue();
+    reference.push(makeItem("c", "r3"));
+    const expectedRemainingBytes = reference.totalBytes;
+
+    const popped = q.shiftN(2);
+    expect(popped.map((m) => m.requestId)).toEqual(["r1", "r2"]);
+    expect(q.length).toBe(1);
+    expect(q.totalBytes).toBe(expectedRemainingBytes);
+    expect(q.peek(0)?.requestId).toBe("r3");
+  });
+
+  test("shiftN(99) on a 3-item queue returns all three; length becomes 0; totalBytes becomes 0", () => {
+    const q = new MessageQueue();
+    q.push(makeItem("a", "r1"));
+    q.push(makeItem("b", "r2"));
+    q.push(makeItem("c", "r3"));
+
+    const popped = q.shiftN(99);
+    expect(popped.map((m) => m.requestId)).toEqual(["r1", "r2", "r3"]);
+    expect(q.length).toBe(0);
+    expect(q.totalBytes).toBe(0);
+  });
+
+  test("after shiftN, a subsequent push up to the budget still succeeds (byte accounting not drifted)", () => {
+    // Tight budget so we can verify the freed bytes are exactly correct.
+    // Each 500-char item ≈ 500*2 + 512 = 1512 bytes.
+    // Budget of 3000 fits two items (3024 > 3000 — actually only one, since 1512+1512=3024 exceeds).
+    // Use 4000: fits two (3024) but not three (4536).
+    const q = new MessageQueue(4_000);
+    expect(q.push(makeItem("a".repeat(500), "r1"))).toBe(true);
+    expect(q.push(makeItem("b".repeat(500), "r2"))).toBe(true);
+    expect(q.push(makeItem("c".repeat(500), "r3"))).toBe(false);
+
+    // Drain both — budget should be fully reclaimed.
+    const popped = q.shiftN(2);
+    expect(popped).toHaveLength(2);
+    expect(q.totalBytes).toBe(0);
+
+    // Now we should be able to push two fresh items again.
+    expect(q.push(makeItem("d".repeat(500), "r4"))).toBe(true);
+    expect(q.push(makeItem("e".repeat(500), "r5"))).toBe(true);
+    expect(q.length).toBe(2);
+  });
+});
+
+describe("MessageQueue exports", () => {
+  test("DEFAULT_MAX_QUEUE_BYTES is importable and positive", () => {
+    expect(typeof DEFAULT_MAX_QUEUE_BYTES).toBe("number");
+    expect(DEFAULT_MAX_QUEUE_BYTES).toBeGreaterThan(0);
+  });
+});

package/src/__tests__/migration-export-http.test.ts

@@ -508,7 +508,7 @@ describe("route policy registration", () => {
     const policy = getPolicy("migrations/validate");
 
     expect(policy).toBeDefined();
-    expect(policy?.requiredScopes).toContain("settings.write");
+    expect(policy?.requiredScopes).toContain("settings.read");
   });
 });
 
@@ -531,15 +531,15 @@ describe("auth policy shape", () => {
     expect(policy!.allowedPrincipalTypes).toHaveLength(4);
   });
 
-  test("export policy matches validate policy shape", async () => {
+  test("export policy differs from validate policy on scopes (validate is read-only)", async () => {
     const { getPolicy } = await import("../runtime/auth/route-policy.js");
     const exportPolicy = getPolicy("migrations/export");
     const validatePolicy = getPolicy("migrations/validate");
 
-    // Both migration endpoints should have the same auth requirements
-    expect(exportPolicy!.requiredScopes).toEqual(
-      validatePolicy!.requiredScopes,
-    );
+    // validate is read-only so requires settings.read; export requires settings.write
+    expect(exportPolicy!.requiredScopes).toEqual(["settings.write"]);
+    expect(validatePolicy!.requiredScopes).toEqual(["settings.read"]);
+    // Both share the same principal types
     expect(exportPolicy!.allowedPrincipalTypes).toEqual(
       validatePolicy!.allowedPrincipalTypes,
     );

package/src/__tests__/migration-import-commit-http.test.ts

@@ -988,23 +988,25 @@ describe("route policy registration", () => {
     expect(policy?.allowedPrincipalTypes).toContain("local");
   });
 
-  test("import policy matches other migration endpoint policies", async () => {
+  test("import policy matches export/preflight but differs from validate on scopes", async () => {
     const { getPolicy } = await import("../runtime/auth/route-policy.js");
     const importPolicy = getPolicy("migrations/import");
     const validatePolicy = getPolicy("migrations/validate");
     const exportPolicy = getPolicy("migrations/export");
     const preflightPolicy = getPolicy("migrations/import-preflight");
 
+    // import, export, and preflight all require settings.write
+    expect(importPolicy!.requiredScopes).toEqual(exportPolicy!.requiredScopes);
     expect(importPolicy!.requiredScopes).toEqual(
-      validatePolicy!.requiredScopes,
+      preflightPolicy!.requiredScopes,
     );
+    expect(importPolicy!.requiredScopes).toEqual(["settings.write"]);
+    // validate is read-only so requires settings.read
+    expect(validatePolicy!.requiredScopes).toEqual(["settings.read"]);
+    // all share the same principal types
     expect(importPolicy!.allowedPrincipalTypes).toEqual(
       validatePolicy!.allowedPrincipalTypes,
     );
-    expect(importPolicy!.requiredScopes).toEqual(exportPolicy!.requiredScopes);
-    expect(importPolicy!.requiredScopes).toEqual(
-      preflightPolicy!.requiredScopes,
-    );
   });
 });
 

package/src/__tests__/migration-import-preflight-http.test.ts

@@ -720,21 +720,22 @@ describe("route policy registration", () => {
     expect(policy?.allowedPrincipalTypes).toContain("local");
   });
 
-  test("import-preflight policy matches validate/export policy shape", async () => {
+  test("import-preflight policy matches export but differs from validate on scopes", async () => {
     const { getPolicy } = await import("../runtime/auth/route-policy.js");
     const preflightPolicy = getPolicy("migrations/import-preflight");
     const validatePolicy = getPolicy("migrations/validate");
     const exportPolicy = getPolicy("migrations/export");
 
+    // preflight and export both require settings.write
     expect(preflightPolicy!.requiredScopes).toEqual(
-      validatePolicy!.requiredScopes,
+      exportPolicy!.requiredScopes,
     );
+    // validate is read-only so requires settings.read
+    expect(validatePolicy!.requiredScopes).toEqual(["settings.read"]);
+    // all share the same principal types
     expect(preflightPolicy!.allowedPrincipalTypes).toEqual(
       validatePolicy!.allowedPrincipalTypes,
     );
-    expect(preflightPolicy!.requiredScopes).toEqual(
-      exportPolicy!.requiredScopes,
-    );
   });
 });
 

package/src/__tests__/migration-validate-http.test.ts

@@ -5,7 +5,7 @@
  * - Success: valid .vbundle archive returns is_valid: true with manifest
  * - Validation failures: invalid gzip, missing entries, bad manifest, checksum mismatches
  * - Request errors: empty body, invalid multipart
- * - Auth: route policy enforcement (settings.write scope required)
+ * - Auth: route policy enforcement (settings.read scope required)
  * - Integration: existing routes are unaffected by the new endpoint
  */
 import { createHash } from "node:crypto";
@@ -638,13 +638,13 @@ describe("handleMigrationValidate", () => {
 // ---------------------------------------------------------------------------
 
 describe("route policy registration", () => {
-  test("migrations/validate policy requires settings.write scope", async () => {
+  test("migrations/validate policy requires settings.read scope", async () => {
     // Import route-policy to verify the registration exists
     const { getPolicy } = await import("../runtime/auth/route-policy.js");
     const policy = getPolicy("migrations/validate");
 
     expect(policy).toBeDefined();
-    expect(policy?.requiredScopes).toContain("settings.write");
+    expect(policy?.requiredScopes).toContain("settings.read");
     expect(policy?.allowedPrincipalTypes).toContain("actor");
     expect(policy?.allowedPrincipalTypes).toContain("svc_gateway");
     expect(policy?.allowedPrincipalTypes).toContain("local");