@vellumai/assistant 0.7.1 → 0.7.2

package/src/__tests__/assistant-event.test.ts

@@ -4,6 +4,7 @@ import type { AssistantEvent } from "../runtime/assistant-event.js";
 import {
   formatSseFrame,
   formatSseHeartbeat,
+  formatSseHeartbeatWithData,
 } from "../runtime/assistant-event.js";
 
 // ── Type / shape tests ────────────────────────────────────────────────────────
@@ -125,3 +126,12 @@ describe("formatSseHeartbeat", () => {
     expect(formatSseHeartbeat().startsWith(":")).toBe(true);
   });
 });
+
+describe("formatSseHeartbeatWithData", () => {
+  test("includes both a comment and a data-bearing event", () => {
+    const hb = formatSseHeartbeatWithData();
+    expect(hb).toContain(": heartbeat\n\n");
+    expect(hb).toContain("event: assistant_event\n");
+    expect(hb).toContain('data: {"type":"heartbeat"}\n');
+  });
+});

package/src/__tests__/assistant-events-sse-hardening.test.ts

@@ -261,7 +261,8 @@ describe("SSE route — heartbeat", () => {
     reader.cancel();
 
     const text = new TextDecoder().decode(value);
-    expect(text).toBe(": heartbeat\n\n");
+    expect(text).toContain(": heartbeat");
+    expect(text).toContain('{"type":"heartbeat"}');
   });
 
   test("emits multiple heartbeats over time", async () => {
@@ -297,7 +298,11 @@ describe("SSE route — heartbeat", () => {
     reader.cancel();
 
     expect(chunks.length).toBeGreaterThan(0);
-    expect(chunks.every((c) => c === ": heartbeat\n\n")).toBe(true);
+    expect(
+      chunks.every(
+        (c) => c.includes(": heartbeat") && c.includes('{"type":"heartbeat"}'),
+      ),
+    ).toBe(true);
   });
 });
 

package/src/__tests__/assistant-feature-flags-integration.test.ts

@@ -12,7 +12,7 @@ import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 // Test-scoped config state
 // ---------------------------------------------------------------------------
 
-const DECLARED_FLAG_ID = "sounds";
+const DECLARED_FLAG_ID = "email-channel";
 const DECLARED_FLAG_KEY = DECLARED_FLAG_ID;
 
 const { isAssistantFeatureFlagEnabled, _setOverridesForTesting } =
@@ -54,10 +54,12 @@ describe("isAssistantFeatureFlagEnabled", () => {
 
   test("missing persisted value falls back to defaults registry defaultEnabled", () => {
     // No explicit config at all — should fall back to defaults registry
-    // which has defaultEnabled: true for sounds
+    // which has defaultEnabled: false for email-channel
     const config = {} as any;
 
-    expect(isAssistantFeatureFlagEnabled(DECLARED_FLAG_KEY, config)).toBe(true);
+    expect(isAssistantFeatureFlagEnabled(DECLARED_FLAG_KEY, config)).toBe(
+      false,
+    );
   });
 
   test("unknown flag defaults to true when no persisted override", () => {
@@ -67,10 +69,12 @@ describe("isAssistantFeatureFlagEnabled", () => {
   });
 
   test("undeclared flag respects persisted override", () => {
-    _setOverridesForTesting({ browser: false });
+    _setOverridesForTesting({ "some-undeclared-flag": false });
     const config = {} as any;
 
-    expect(isAssistantFeatureFlagEnabled("browser", config)).toBe(false);
+    expect(isAssistantFeatureFlagEnabled("some-undeclared-flag", config)).toBe(
+      false,
+    );
   });
 });
 
@@ -87,7 +91,7 @@ describe("isAssistantFeatureFlagEnabled with skillFlagKey", () => {
     ).toBe(false);
   });
 
-  test("enabled when no override set (registry default is true)", () => {
+  test("disabled when no override set (registry default is false)", () => {
     const config = {} as any;
 
     expect(
@@ -95,6 +99,6 @@ describe("isAssistantFeatureFlagEnabled with skillFlagKey", () => {
         skillFlagKey({ featureFlag: DECLARED_FLAG_ID })!,
         config,
       ),
-    ).toBe(true);
+    ).toBe(false);
   });
 });

package/src/__tests__/background-shell-host-bash.test.ts

@@ -74,7 +74,6 @@ mock.module("../config/loader.js", () => ({
   getConfig: () => mockConfig,
   loadConfig: () => mockConfig,
   invalidateConfigCache: () => {},
-  saveConfig: () => {},
   loadRawConfig: () => ({}),
   saveRawConfig: () => {},
   getNestedValue: () => undefined,
@@ -91,10 +90,16 @@ mock.module("../util/logger.js", () => ({
 // Mock HostBashProxy singleton — proxy delegation tests configure this.
 let mockProxyAvailable = false;
 let mockProxyRequestImpl: (
-  input: { command: string; working_dir?: string; timeout_seconds?: number; env?: Record<string, string> },
+  input: {
+    command: string;
+    working_dir?: string;
+    timeout_seconds?: number;
+    env?: Record<string, string>;
+  },
   conversationId: string,
   signal?: AbortSignal,
-) => Promise<ToolExecutionResult> = () => Promise.resolve({ content: "", isError: false });
+) => Promise<ToolExecutionResult> = () =>
+  Promise.resolve({ content: "", isError: false });
 
 mock.module("../daemon/host-bash-proxy.js", () => ({
   HostBashProxy: {
@@ -182,8 +187,7 @@ describe("host_bash background mode — proxy path", () => {
     };
     setupMockProxy(proxyResult);
 
-    const ctx = makeContext({
-    });
+    const ctx = makeContext({});
 
     const result = await hostShellTool.execute(
       { command: "echo bg-proxy", background: true },
@@ -203,8 +207,7 @@ describe("host_bash background mode — proxy path", () => {
     };
     setupMockProxy(proxyResult);
 
-    const ctx = makeContext({
-    });
+    const ctx = makeContext({});
 
     await hostShellTool.execute(
       { command: "echo bg-proxy", background: true },
@@ -227,8 +230,7 @@ describe("host_bash background mode — proxy path", () => {
     };
     setupMockProxy(proxyResult);
 
-    const ctx = makeContext({
-    });
+    const ctx = makeContext({});
 
     await hostShellTool.execute(
       { command: "echo bg-proxy", background: true },
@@ -257,8 +259,7 @@ describe("host_bash background mode — proxy path", () => {
     };
     setupMockProxy(proxyResult);
 
-    const ctx = makeContext({
-    });
+    const ctx = makeContext({});
 
     await hostShellTool.execute(
       { command: "bad-command", background: true },
@@ -280,8 +281,7 @@ describe("host_bash background mode — proxy path", () => {
     mockProxyRequestImpl = () =>
       Promise.reject(new Error("proxy transport error"));
 
-    const ctx = makeContext({
-    });
+    const ctx = makeContext({});
 
     await hostShellTool.execute(
       { command: "echo fail", background: true },
@@ -305,8 +305,7 @@ describe("host_bash background mode — proxy path", () => {
     };
     setupMockProxy(proxyResult);
 
-    const ctx = makeContext({
-    });
+    const ctx = makeContext({});
 
     const result = await hostShellTool.execute(
       { command: "echo bg-proxy", background: true },

package/src/__tests__/bootstrap-turn-cleanup.test.ts

@@ -0,0 +1,44 @@
+import { describe, expect, test } from "bun:test";
+
+import {
+  BOOTSTRAP_CLEANUP_USER_TURN_THRESHOLD,
+  countBootstrapUserTurns,
+  shouldCleanupBootstrapAfterTurn,
+} from "../daemon/bootstrap-turn-cleanup.js";
+
+function message(role: string, content: string) {
+  return { role, content };
+}
+
+describe("bootstrap turn cleanup", () => {
+  test("does not count the hidden wake-up greeting as a user turn", () => {
+    const messages = [
+      message(
+        "user",
+        JSON.stringify([{ type: "text", text: "Wake up, my friend." }]),
+      ),
+      message("assistant", "hello"),
+      message("user", "real request"),
+    ];
+
+    expect(countBootstrapUserTurns(messages)).toBe(1);
+  });
+
+  test("cleans up after the configured user-turn threshold", () => {
+    const messages = Array.from(
+      { length: BOOTSTRAP_CLEANUP_USER_TURN_THRESHOLD },
+      (_value, index) => message("user", `request ${index + 1}`),
+    );
+
+    expect(shouldCleanupBootstrapAfterTurn(messages)).toBe(true);
+  });
+
+  test("keeps bootstrap before the configured user-turn threshold", () => {
+    const messages = Array.from(
+      { length: BOOTSTRAP_CLEANUP_USER_TURN_THRESHOLD - 1 },
+      (_value, index) => message("user", `request ${index + 1}`),
+    );
+
+    expect(shouldCleanupBootstrapAfterTurn(messages)).toBe(false);
+  });
+});

package/src/__tests__/btw-routes.test.ts

@@ -73,13 +73,16 @@ mock.module("../prompts/persona-resolver.js", () => ({
 
 mock.module("../runtime/routes/identity-intro-cache.js", () => ({
   getCachedIntro: () => null,
+  readWorkspaceIdentityIntro: () => null,
   setCachedIntro: () => {},
   computeIdentityContentHash: () => "test-hash",
 }));
 
 // Mock getOrCreateConversation from conversation-store so the handler
 // never touches DaemonServer.
-const mockGetOrCreateConversation = mock(async (_id: string) => makeMockSession());
+const mockGetOrCreateConversation = mock(async (_id: string) =>
+  makeMockSession(),
+);
 
 mock.module("../daemon/conversation-store.js", () => ({
   getOrCreateConversation: mockGetOrCreateConversation,
@@ -114,7 +117,10 @@ import type {
   SendMessageOptions,
 } from "../providers/types.js";
 import { ROUTES } from "../runtime/routes/btw-routes.js";
-import { BadRequestError, ServiceUnavailableError } from "../runtime/routes/errors.js";
+import {
+  BadRequestError,
+  ServiceUnavailableError,
+} from "../runtime/routes/errors.js";
 import type { RouteHandlerArgs } from "../runtime/routes/types.js";
 
 // ---------------------------------------------------------------------------
@@ -199,7 +205,8 @@ async function readStream(stream: ReadableStream<Uint8Array>): Promise<string> {
     chunks.push(value);
   }
   return new TextDecoder().decode(
-    new Uint8Array(chunks.reduce((a, c) => a + c.length, 0)).buffer.byteLength === 0
+    new Uint8Array(chunks.reduce((a, c) => a + c.length, 0)).buffer
+      .byteLength === 0
       ? new Uint8Array(0)
       : Buffer.concat(chunks),
   );
@@ -415,6 +422,8 @@ describe("POST /v1/btw", () => {
     });
     await readStream(result as ReadableStream<Uint8Array>);
 
-    expect(mockGetOrCreateConversation).toHaveBeenCalledWith("existing-conv-id");
+    expect(mockGetOrCreateConversation).toHaveBeenCalledWith(
+      "existing-conv-id",
+    );
   });
 });

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

@@ -38,6 +38,10 @@ mock.module("../config/loader.js", () => {
     },
     memory: { enabled: false },
     notifications: {},
+    ingress: {
+      enabled: true,
+      publicBaseUrl: "https://generic.example.com",
+    },
     services: {
       tts: {
         mode: "your-own" as const,
@@ -77,7 +81,6 @@ mock.module("../config/loader.js", () => {
     getConfig: () => config,
     loadConfig: () => config,
     loadRawConfig: () => ({}),
-    saveConfig: () => {},
     saveRawConfig: () => {},
     invalidateConfigCache: () => {},
     applyNestedDefaults: (c: unknown) => c,
@@ -468,6 +471,7 @@ describe("call-controller", () => {
     const cfg = loadConfig();
     cfg.services.tts.provider = "elevenlabs";
     cfg.services.tts.providers["fish-audio"].referenceId = "";
+    cfg.ingress.publicBaseUrl = "https://generic.example.com";
     // Reset TTS provider registry to ensure clean state
     registerTestTtsProviders();
   });
@@ -2532,6 +2536,50 @@ describe("call-controller", () => {
     controller.destroy();
   });
 
+  test("synthesized provider: play URL uses public base URL", async () => {
+    const cfg = loadConfig();
+    cfg.ingress.publicBaseUrl = "https://twilio.example.com/";
+    cfg.services.tts.provider = "fish-audio";
+    cfg.services.tts.providers["fish-audio"].referenceId = "fish-ref-123";
+
+    _resetTtsProviderRegistry();
+    const fishAudioStreaming: TtsProvider = {
+      id: "fish-audio",
+      capabilities: {
+        supportsStreaming: true,
+        supportedFormats: ["mp3", "wav", "opus"],
+      },
+      async synthesize() {
+        return {
+          audio: Buffer.from("fish-audio-buffer"),
+          contentType: "audio/mpeg",
+        };
+      },
+      async synthesizeStream(_request, onChunk) {
+        onChunk(Buffer.from("fish-audio-stream"));
+        return {
+          audio: Buffer.from("fish-audio-stream"),
+          contentType: "audio/mpeg",
+        };
+      },
+    };
+    registerTtsProvider(fishAudioStreaming);
+
+    mockStartVoiceTurn.mockImplementation(
+      createMockVoiceTurn(["Hello from synthesized path."]),
+    );
+    const { relay, controller } = setupController();
+
+    await controller.handleCallerUtterance("Hi");
+
+    expect(relay.sentPlayUrls.length).toBeGreaterThan(0);
+    expect(relay.sentPlayUrls[0]).toStartWith(
+      "https://twilio.example.com/v1/audio/",
+    );
+
+    controller.destroy();
+  });
+
   test("Deepgram selected path resolves useSynthesizedPath to true", () => {
     const cfg = loadConfig();
     cfg.services.tts.provider = "deepgram";

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

@@ -28,8 +28,6 @@ mock.module("../calls/twilio-config.js", () => ({
     accountSid: "AC_test",
     authToken: "test_token",
     phoneNumber: assistantId === "ast-alpha" ? "+15550003333" : "+15550001111",
-    webhookBaseUrl: "https://test.example.com",
-    wssBaseUrl: "wss://test.example.com",
   }),
 }));
 

package/src/__tests__/call-routes-http.test.ts

@@ -77,8 +77,6 @@ mock.module("../calls/twilio-config.js", () => ({
     accountSid: "AC_test",
     authToken: "test_token",
     phoneNumber: assistantId === "asst-alpha" ? "+15550009999" : "+15550001111",
-    webhookBaseUrl: "https://test.example.com",
-    wssBaseUrl: "wss://test.example.com",
   }),
 }));
 

package/src/__tests__/channel-readiness-service.test.ts

@@ -292,7 +292,7 @@ describe("ChannelReadinessService", () => {
   test("phone readiness accepts managed callback routing when ingress is absent", async () => {
     mockGetIsPlatform = true;
     mockHasTwilioCredentials = true;
-    mockTwilioPhoneNumber = "+15555550123";
+    mockTwilioPhoneNumber = "+15550123";
 
     const readiness = createReadinessService();
     const [snapshot] = await readiness.getReadiness("phone");
@@ -305,6 +305,64 @@ describe("ChannelReadinessService", () => {
     });
   });
 
+  test("phone readiness accepts Twilio-specific ingress without generic public ingress", async () => {
+    mockHasTwilioCredentials = true;
+    mockTwilioPhoneNumber = "+15550123";
+    mockRawConfig = {
+      ingress: {
+        publicBaseUrl: "https://twilio.example.com",
+      },
+    };
+
+    const readiness = createReadinessService();
+    const [snapshot] = await readiness.getReadiness("phone");
+
+    expect(snapshot.ready).toBe(true);
+    expect(snapshot.localChecks).toContainEqual({
+      name: "ingress",
+      passed: true,
+      message: "Twilio public ingress URL is configured",
+    });
+  });
+
+  test("phone readiness fails when publicBaseUrl is whitespace only", async () => {
+    mockHasTwilioCredentials = true;
+    mockTwilioPhoneNumber = "+15550123";
+    mockRawConfig = {
+      ingress: {
+        publicBaseUrl: "   ",
+      },
+    };
+
+    const readiness = createReadinessService();
+    const [snapshot] = await readiness.getReadiness("phone");
+
+    expect(snapshot.ready).toBe(false);
+    expect(snapshot.reasons).toContainEqual({
+      code: "ingress",
+      text: "No Twilio public ingress URL or managed callback route is configured",
+    });
+  });
+
+  test("telegram readiness fails when publicBaseUrl is empty", async () => {
+    mockSecureKeys[credentialKey("telegram", "bot_token")] = "123:abc";
+    mockSecureKeys[credentialKey("telegram", "webhook_secret")] = "secret";
+    mockRawConfig = {
+      ingress: {
+        publicBaseUrl: "",
+      },
+    };
+
+    const readiness = createReadinessService();
+    const [snapshot] = await readiness.getReadiness("telegram");
+
+    expect(snapshot.ready).toBe(false);
+    expect(snapshot.reasons).toContainEqual({
+      code: "ingress",
+      text: "No public ingress URL or managed callback route is configured",
+    });
+  });
+
   test("getReadiness with no channel returns all registered channels", async () => {
     service.registerProbe(
       makeProbe("phone", [{ name: "a", passed: true, message: "ok" }]),

package/src/__tests__/checker.test.ts

@@ -51,7 +51,6 @@ mock.module("../config/loader.js", () => ({
   getConfig: () => testConfig,
   loadConfig: () => testConfig,
   invalidateConfigCache: () => {},
-  saveConfig: () => {},
   loadRawConfig: () => ({}),
   saveRawConfig: () => {},
   getNestedValue: () => undefined,
@@ -117,14 +116,14 @@ import * as platformModule from "../util/platform.js";
 /** Default gateway thresholds matching the old config fallback defaults. */
 const DEFAULT_GATEWAY_THRESHOLDS = {
   interactive: "low",
-  background: "medium",
+  autonomous: "medium",
   headless: "none",
 } as const;
 
 /** Strict gateway thresholds — equivalent to autoApproveUpTo: "none". */
 const STRICT_GATEWAY_THRESHOLDS = {
   interactive: "none",
-  background: "none",
+  autonomous: "none",
   headless: "none",
 } as const;
 
@@ -201,7 +200,7 @@ describe("Permission Checker", () => {
   beforeEach(() => {
     // Reset IPC mock to low risk (tests override as needed)
     mockRisk("low");
-    // Default gateway threshold (conversation: low, background: medium, headless: none)
+    // Default gateway threshold (interactive: low, autonomous: medium, headless: none)
     mockIpcResponse("get_global_thresholds", DEFAULT_GATEWAY_THRESHOLDS);
     // Clear the gateway threshold cache so each test gets a fresh threshold read
     _clearGlobalCacheForTesting();