@vellumai/assistant 0.6.2 → 0.6.4

package/src/__tests__/relay-server.test.ts

@@ -44,7 +44,7 @@ mock.module("../daemon/identity-helpers.js", () => ({
   getAssistantName: () => mockAssistantName,
 }));
 
-// ── User-reference mock (isolate from real USER.md) ──────────────────
+// ── User-reference mock (isolate from real guardian persona) ────────
 
 let mockUserReference = "my human";
 // eslint-disable-next-line @typescript-eslint/no-require-imports
@@ -97,6 +97,52 @@ const mockConfig = {
 
 mock.module("../config/loader.js", () => ({
   getConfig: () => mockConfig,
+  loadConfig: () => mockConfig,
+}));
+
+// ── TTS provider mocks (for call-speech-output) ─────────────────────
+
+let mockTtsProviderId: string = "elevenlabs";
+let mockTtsSupportsStreaming: boolean = false;
+let mockTtsSynthesizeStream: Mock<any> | null = null;
+let mockTtsSynthesize: Mock<any> | null = null;
+
+mock.module("../tts/tts-config-resolver.js", () => ({
+  resolveTtsConfig: () => ({
+    provider: mockTtsProviderId,
+    providerConfig: {
+      voiceId: "test-voice",
+      format: "mp3",
+      referenceId: "test-ref-id",
+    },
+  }),
+}));
+
+mock.module("../tts/provider-registry.js", () => ({
+  getTtsProvider: () => ({
+    id: mockTtsProviderId,
+    capabilities: {
+      supportsStreaming: mockTtsSupportsStreaming,
+      supportedFormats: ["mp3"],
+    },
+    synthesize: mockTtsSynthesize
+      ? (...args: unknown[]) => mockTtsSynthesize!(...args)
+      : async () => ({
+          audio: Buffer.from("fake-audio"),
+          contentType: "audio/mpeg",
+        }),
+    synthesizeStream: mockTtsSynthesizeStream
+      ? (...args: unknown[]) => mockTtsSynthesizeStream!(...args)
+      : undefined,
+  }),
+  registerTtsProvider: () => {},
+  listTtsProviders: () => [],
+  _resetTtsProviderRegistry: () => {},
+}));
+
+// Mock public ingress URLs for synthesized TTS path
+mock.module("../inbound/public-ingress-urls.js", () => ({
+  getPublicBaseUrl: () => "https://test.example.com",
 }));
 
 // ── Helpers for building mock provider responses ────────────────────
@@ -335,11 +381,17 @@ describe("relay-server", () => {
     resetTables();
     activeRelayConnections.clear();
     mockUserReference = "my human";
+    mockAssistantName = "Vellum";
     mockSendMessage.mockImplementation(createMockProviderResponse(["Hello"]));
     mockConfig.calls.verification.enabled = false;
     mockConfig.calls.verification.maxAttempts = 3;
     mockConfig.calls.verification.codeLength = 6;
     mockConfig.calls.callerIdentity.userNumber = undefined;
+    // Reset TTS provider mocks to native (non-streaming) path
+    mockTtsProviderId = "elevenlabs";
+    mockTtsSupportsStreaming = false;
+    mockTtsSynthesizeStream = null;
+    mockTtsSynthesize = null;
     setVoiceBridgeDeps({
       getOrCreateConversation: async (conversationId) => {
         const session = {
@@ -4112,7 +4164,7 @@ describe("relay-server", () => {
 
   // ── resolveGuardianLabel resolution priority ─────────────────────────
 
-  test("guardian label: USER.md name takes precedence over Contact.displayName", async () => {
+  test("guardian label: guardian persona name takes precedence over Contact.displayName", async () => {
     mockUserReference = "Alice";
 
     // Create a guardian binding with a different displayName
@@ -4146,7 +4198,7 @@ describe("relay-server", () => {
 
     expect(relay.getConnectionState()).toBe("awaiting_name");
 
-    // The greeting should use the USER.md name ("Alice"), not Contact.displayName ("Bob")
+    // The greeting should use the guardian persona name ("Alice"), not Contact.displayName ("Bob")
     const textMessages = ws.sentMessages
       .map((raw) => JSON.parse(raw) as { type: string; token?: string })
       .filter((m) => m.type === "text");
@@ -4157,7 +4209,7 @@ describe("relay-server", () => {
     relay.destroy();
   });
 
-  test("guardian label: Contact.displayName used when USER.md is empty", async () => {
+  test("guardian label: Contact.displayName used when guardian persona name is empty", async () => {
     mockUserReference = "my human";
 
     // Create a guardian binding with a displayName
@@ -4201,7 +4253,7 @@ describe("relay-server", () => {
     relay.destroy();
   });
 
-  test("guardian label: DEFAULT_USER_REFERENCE used when both USER.md and Contact.displayName are empty", async () => {
+  test("guardian label: DEFAULT_USER_REFERENCE used when both guardian persona name and Contact.displayName are empty", async () => {
     mockUserReference = "my human";
 
     // No guardian binding — no Contact.displayName available
@@ -4236,4 +4288,370 @@ describe("relay-server", () => {
 
     relay.destroy();
   });
+
+  // ── Provider-aware call speech output ──────────────────────────────
+
+  describe("provider-aware system prompts", () => {
+    test("native TTS provider: verification prompt uses sendTextToken (text messages)", async () => {
+      // Ensure native (non-streaming) TTS path
+      mockTtsSupportsStreaming = false;
+      mockTtsSynthesizeStream = null;
+
+      ensureConversation("conv-native-tts-verify");
+      const session = createCallSession({
+        conversationId: "conv-native-tts-verify",
+        provider: "twilio",
+        fromNumber: "+15559999999",
+        toNumber: "+15551111111",
+      });
+
+      createPendingVoiceGuardianChallenge("654321");
+
+      const { ws, relay } = createMockWs(session.id);
+
+      await relay.handleMessage(
+        JSON.stringify({
+          type: "setup",
+          callSid: "CA_native_tts_verify",
+          from: "+15559999999",
+          to: "+15551111111",
+        }),
+      );
+
+      expect(relay.getConnectionState()).toBe("verification_pending");
+
+      // With native TTS, the prompt should appear as a text message (not play)
+      const textMessages = ws.sentMessages
+        .map((raw) => JSON.parse(raw) as { type: string; token?: string })
+        .filter((m) => m.type === "text");
+      const playMessages = ws.sentMessages
+        .map((raw) => JSON.parse(raw) as { type: string; source?: string })
+        .filter((m) => m.type === "play");
+
+      expect(
+        textMessages.some((m) => (m.token ?? "").includes("verification code")),
+      ).toBe(true);
+      expect(playMessages.length).toBe(0);
+
+      relay.destroy();
+    });
+
+    test("synthesized TTS provider: verification prompt uses sendPlayUrl (play messages)", async () => {
+      // Enable synthesized (streaming) TTS path
+      mockTtsProviderId = "fish-audio";
+      mockTtsSupportsStreaming = true;
+      mockTtsSynthesizeStream = jest.fn(
+        async (_request: unknown, onChunk: (chunk: Uint8Array) => void) => {
+          onChunk(new Uint8Array([0x01, 0x02, 0x03]));
+          return {
+            audio: Buffer.from([0x01, 0x02, 0x03]),
+            contentType: "audio/mpeg",
+          };
+        },
+      );
+
+      ensureConversation("conv-synth-tts-verify");
+      const session = createCallSession({
+        conversationId: "conv-synth-tts-verify",
+        provider: "twilio",
+        fromNumber: "+15559999998",
+        toNumber: "+15551111111",
+      });
+
+      createPendingVoiceGuardianChallenge("654321");
+
+      const { ws, relay } = createMockWs(session.id);
+
+      await relay.handleMessage(
+        JSON.stringify({
+          type: "setup",
+          callSid: "CA_synth_tts_verify",
+          from: "+15559999998",
+          to: "+15551111111",
+        }),
+      );
+
+      expect(relay.getConnectionState()).toBe("verification_pending");
+
+      // Allow async synthesis to complete
+      await new Promise((resolve) => setTimeout(resolve, 50));
+
+      // With synthesized TTS, the prompt should appear as a play message
+      const playMessages = ws.sentMessages
+        .map((raw) => JSON.parse(raw) as { type: string; source?: string })
+        .filter((m) => m.type === "play");
+
+      expect(playMessages.length).toBeGreaterThan(0);
+      expect(playMessages[0].source).toContain("/v1/audio/");
+
+      // The synthesizeStream mock should have been called
+      expect(mockTtsSynthesizeStream).toHaveBeenCalled();
+
+      relay.destroy();
+    });
+
+    test("native TTS provider: name capture greeting uses text messages", async () => {
+      // Ensure native (non-streaming) TTS path
+      mockTtsSupportsStreaming = false;
+      mockTtsSynthesizeStream = null;
+
+      ensureConversation("conv-native-name-capture");
+      const session = createCallSession({
+        conversationId: "conv-native-name-capture",
+        provider: "twilio",
+        fromNumber: "+15559990097",
+        toNumber: "+15551111111",
+      });
+
+      mockAssistantName = "Jarvis";
+
+      const { ws, relay } = createMockWs(session.id);
+
+      await relay.handleMessage(
+        JSON.stringify({
+          type: "setup",
+          callSid: "CA_native_name_capture",
+          from: "+15559990097",
+          to: "+15551111111",
+        }),
+      );
+
+      expect(relay.getConnectionState()).toBe("awaiting_name");
+
+      // With native TTS, the greeting should be a text message
+      const textMessages = ws.sentMessages
+        .map((raw) => JSON.parse(raw) as { type: string; token?: string })
+        .filter((m) => m.type === "text");
+      const playMessages = ws.sentMessages
+        .map((raw) => JSON.parse(raw) as { type: string; source?: string })
+        .filter((m) => m.type === "play");
+
+      expect(
+        textMessages.some((m) => (m.token ?? "").includes("don't recognize")),
+      ).toBe(true);
+      expect(playMessages.length).toBe(0);
+
+      // Reset
+      mockAssistantName = "Vellum";
+      relay.destroy();
+    });
+
+    test("synthesized TTS provider: name capture greeting uses play messages", async () => {
+      // Enable synthesized (streaming) TTS path
+      mockTtsProviderId = "fish-audio";
+      mockTtsSupportsStreaming = true;
+      mockTtsSynthesizeStream = jest.fn(
+        async (_request: unknown, onChunk: (chunk: Uint8Array) => void) => {
+          onChunk(new Uint8Array([0x04, 0x05, 0x06]));
+          return {
+            audio: Buffer.from([0x04, 0x05, 0x06]),
+            contentType: "audio/mpeg",
+          };
+        },
+      );
+
+      ensureConversation("conv-synth-name-capture");
+      const session = createCallSession({
+        conversationId: "conv-synth-name-capture",
+        provider: "twilio",
+        fromNumber: "+15559990098",
+        toNumber: "+15551111111",
+      });
+
+      mockAssistantName = "Jarvis";
+
+      const { ws, relay } = createMockWs(session.id);
+
+      await relay.handleMessage(
+        JSON.stringify({
+          type: "setup",
+          callSid: "CA_synth_name_capture",
+          from: "+15559990098",
+          to: "+15551111111",
+        }),
+      );
+
+      expect(relay.getConnectionState()).toBe("awaiting_name");
+
+      // Allow async synthesis to complete
+      await new Promise((resolve) => setTimeout(resolve, 50));
+
+      // With synthesized TTS, the greeting should be a play message
+      const playMessages = ws.sentMessages
+        .map((raw) => JSON.parse(raw) as { type: string; source?: string })
+        .filter((m) => m.type === "play");
+
+      expect(playMessages.length).toBeGreaterThan(0);
+      expect(playMessages[0].source).toContain("/v1/audio/");
+
+      // The synthesizeStream mock should have been called
+      expect(mockTtsSynthesizeStream).toHaveBeenCalled();
+
+      // Reset
+      mockAssistantName = "Vellum";
+      relay.destroy();
+    });
+
+    test("synthesized TTS provider: falls back to text on synthesis failure", async () => {
+      // Configure synthesized path but make it fail
+      mockTtsProviderId = "fish-audio";
+      mockTtsSupportsStreaming = true;
+      mockTtsSynthesizeStream = jest.fn(async () => {
+        throw new Error("Synthesis service unavailable");
+      });
+
+      ensureConversation("conv-synth-fallback");
+      const session = createCallSession({
+        conversationId: "conv-synth-fallback",
+        provider: "twilio",
+        fromNumber: "+15559990099",
+        toNumber: "+15551111111",
+      });
+
+      createPendingVoiceGuardianChallenge("654321");
+
+      const { ws, relay } = createMockWs(session.id);
+
+      await relay.handleMessage(
+        JSON.stringify({
+          type: "setup",
+          callSid: "CA_synth_fallback",
+          from: "+15559990099",
+          to: "+15551111111",
+        }),
+      );
+
+      expect(relay.getConnectionState()).toBe("verification_pending");
+
+      // Allow async synthesis (and fallback) to complete
+      await new Promise((resolve) => setTimeout(resolve, 50));
+
+      // Should have fallen back to text messages after synthesis failure
+      const textMessages = ws.sentMessages
+        .map((raw) => JSON.parse(raw) as { type: string; token?: string })
+        .filter((m) => m.type === "text");
+
+      expect(
+        textMessages.some((m) => (m.token ?? "").includes("verification code")),
+      ).toBe(true);
+
+      relay.destroy();
+    });
+
+    test("Deepgram TTS provider: synthesis failure does NOT fall back to text (fail-fast policy)", async () => {
+      // Configure Deepgram as the synthesized provider with failing synthesis.
+      // Deepgram uses buffer synthesis (no streaming), so we fail synthesize().
+      mockTtsProviderId = "deepgram";
+      mockTtsSupportsStreaming = false;
+      mockTtsSynthesizeStream = null;
+      mockTtsSynthesize = jest.fn(async () => {
+        const err = new Error("Deepgram TTS returned 503: service unavailable");
+        (err as Error & { code?: string }).code = "DEEPGRAM_TTS_HTTP_ERROR";
+        throw err;
+      });
+
+      ensureConversation("conv-deepgram-fail");
+      const session = createCallSession({
+        conversationId: "conv-deepgram-fail",
+        provider: "twilio",
+        fromNumber: "+15559990088",
+        toNumber: "+15551111111",
+      });
+
+      createPendingVoiceGuardianChallenge("123456");
+
+      const { ws, relay } = createMockWs(session.id);
+
+      await relay.handleMessage(
+        JSON.stringify({
+          type: "setup",
+          callSid: "CA_deepgram_fail",
+          from: "+15559990088",
+          to: "+15551111111",
+        }),
+      );
+
+      // Allow async synthesis (and error propagation) to complete
+      await new Promise((resolve) => setTimeout(resolve, 100));
+
+      // Deepgram failure should NOT have produced text fallback messages
+      // containing the verification prompt content, because Deepgram
+      // synthesis failures propagate rather than falling back to native TTS.
+      const textMessages = ws.sentMessages
+        .map((raw) => JSON.parse(raw) as { type: string; token?: string })
+        .filter((m) => m.type === "text");
+      const playMessages = ws.sentMessages
+        .map((raw) => JSON.parse(raw) as { type: string })
+        .filter((m) => m.type === "play");
+
+      // No play URL should have been sent either (synthesis failed before
+      // first chunk).
+      expect(playMessages.length).toBe(0);
+
+      // Unlike Fish Audio which falls back to text, Deepgram should NOT
+      // have any text tokens containing the verification prompt.
+      const hasVerificationText = textMessages.some((m) =>
+        (m.token ?? "").includes("verification code"),
+      );
+      expect(hasVerificationText).toBe(false);
+
+      relay.destroy();
+    });
+
+    test("native TTS provider: DTMF callee verification failure prompt uses text messages", async () => {
+      // Ensure native (non-streaming) TTS path
+      mockTtsSupportsStreaming = false;
+      mockTtsSynthesizeStream = null;
+
+      ensureConversation("conv-native-callee-fail");
+      ensureConversation("conv-native-callee-fail-origin");
+      mockConfig.calls.verification.enabled = true;
+      mockConfig.calls.verification.maxAttempts = 1;
+
+      const session = createCallSession({
+        conversationId: "conv-native-callee-fail",
+        provider: "twilio",
+        fromNumber: "+15551111111",
+        toNumber: "+15552222222",
+        task: "Call +15552222222",
+        initiatedFromConversationId: "conv-native-callee-fail-origin",
+      });
+
+      const { ws, relay } = createMockWs(session.id);
+
+      await relay.handleMessage(
+        JSON.stringify({
+          type: "setup",
+          callSid: "CA_native_callee_fail",
+          from: "+15551111111",
+          to: "+15552222222",
+        }),
+      );
+
+      expect(relay.getConnectionState()).toBe("verification_pending");
+      expect(relay.getVerificationCode()).not.toBeNull();
+
+      // Send wrong digits
+      for (const digit of "000000") {
+        await relay.handleMessage(JSON.stringify({ type: "dtmf", digit }));
+      }
+
+      // Should have sent "Verification failed" as text (not play)
+      const textMessages = ws.sentMessages
+        .map((raw) => JSON.parse(raw) as { type: string; token?: string })
+        .filter((m) => m.type === "text");
+      const playMessages = ws.sentMessages
+        .map((raw) => JSON.parse(raw) as { type: string; source?: string })
+        .filter((m) => m.type === "play");
+
+      expect(
+        textMessages.some((m) =>
+          (m.token ?? "").includes("Verification failed"),
+        ),
+      ).toBe(true);
+      expect(playMessages.length).toBe(0);
+
+      relay.destroy();
+    });
+  });
 });

package/src/__tests__/require-fresh-approval.test.ts

@@ -108,16 +108,20 @@ mock.module("../permissions/checker.js", () => ({
 
 mock.module("../memory/tool-usage-store.js", () => ({
   recordToolInvocation: () => {},
+  getRecentInvocations: () => [],
+  rotateToolInvocations: () => 0,
 }));
 
 mock.module("../tools/registry.js", () => ({
   getTool: (name: string) => {
     if (name === "unknown_tool") return undefined;
+    const isGmailTool = name.startsWith("gmail_");
     return {
       name,
       description: "test tool",
-      category: "credential-execution",
+      category: isGmailTool ? "gmail" : "credential-execution",
       defaultRiskLevel: "high",
+      executionTarget: isGmailTool ? ("host" as const) : undefined,
       getDefinition: () => ({}),
       execute: async () => fakeToolResult,
     };
@@ -257,6 +261,41 @@ describe("requireFreshApproval: non-interactive guardian denial", () => {
     expect(result.isError).toBe(false);
   });
 
+  test("medium-risk gmail archive is auto-approved in non-interactive guardian sessions", async () => {
+    riskOverride = RiskLevel.Medium;
+    checkResultOverride = {
+      decision: "prompt",
+      reason: "Needs approval",
+    };
+
+    const executor = new ToolExecutor(makePrompter());
+    const result = await executor.execute(
+      "gmail_archive",
+      { query: "in:inbox", confidence: 0.92 },
+      makeContext({ isInteractive: false, trustClass: "guardian" }),
+    );
+
+    expect(result.isError).toBe(false);
+  });
+
+  test("high-risk gmail send_draft is denied in non-interactive guardian sessions", async () => {
+    riskOverride = RiskLevel.High;
+    checkResultOverride = {
+      decision: "prompt",
+      reason: "Needs approval",
+    };
+
+    const executor = new ToolExecutor(makePrompter());
+    const result = await executor.execute(
+      "gmail_send_draft",
+      { draft_id: "draft-123", confidence: 0.99 },
+      makeContext({ isInteractive: false, trustClass: "guardian" }),
+    );
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain("requires user approval");
+  });
+
   test("low-risk tools are still auto-approved in non-interactive guardian sessions", async () => {
     riskOverride = RiskLevel.Low;
     checkResultOverride = {

package/src/__tests__/sanitize-config-for-transfer.test.ts

@@ -0,0 +1,132 @@
+import { describe, expect, test } from "bun:test";
+
+import { sanitizeConfigForTransfer } from "../config/sanitize-for-transfer.js";
+
+describe("sanitizeConfigForTransfer", () => {
+  test("strips all four field groups", () => {
+    const input = {
+      ingress: {
+        publicBaseUrl: "https://example.com",
+        enabled: true,
+        webhook: { path: "/hook" },
+      },
+      daemon: { port: 3000, logLevel: "debug" },
+      skills: {
+        load: {
+          extraDirs: ["/custom/skills"],
+          builtIn: true,
+        },
+      },
+      name: "my-assistant",
+    };
+
+    const result = JSON.parse(sanitizeConfigForTransfer(JSON.stringify(input)));
+
+    expect(result.ingress.publicBaseUrl).toBe("");
+    expect(result.ingress.enabled).toBeUndefined();
+    expect(result.daemon).toBeUndefined();
+    expect(result.skills.load.extraDirs).toEqual([]);
+  });
+
+  test("preserves non-target fields unchanged", () => {
+    const input = {
+      name: "test",
+      model: "claude-3",
+      ingress: {
+        publicBaseUrl: "https://example.com",
+        enabled: true,
+        webhook: { path: "/hook" },
+        rateLimit: { max: 100 },
+      },
+      daemon: { port: 3000 },
+      skills: {
+        load: {
+          extraDirs: ["/dir"],
+          builtIn: true,
+        },
+        catalog: ["skill-a"],
+      },
+      memory: { enabled: true },
+    };
+
+    const result = JSON.parse(sanitizeConfigForTransfer(JSON.stringify(input)));
+
+    expect(result.name).toBe("test");
+    expect(result.model).toBe("claude-3");
+    expect(result.memory).toEqual({ enabled: true });
+    expect(result.skills.catalog).toEqual(["skill-a"]);
+    expect(result.skills.load.builtIn).toBe(true);
+  });
+
+  test("preserves nested ingress fields other than publicBaseUrl and enabled", () => {
+    const input = {
+      ingress: {
+        publicBaseUrl: "https://old.url",
+        enabled: false,
+        webhook: { path: "/webhook", secret: "abc" },
+        rateLimit: { max: 50, window: 60 },
+      },
+    };
+
+    const result = JSON.parse(sanitizeConfigForTransfer(JSON.stringify(input)));
+
+    expect(result.ingress.webhook).toEqual({ path: "/webhook", secret: "abc" });
+    expect(result.ingress.rateLimit).toEqual({ max: 50, window: 60 });
+    expect(result.ingress.publicBaseUrl).toBe("");
+    expect(result.ingress.enabled).toBeUndefined();
+  });
+
+  test("handles config missing some target fields", () => {
+    const input = {
+      name: "test",
+      ingress: { webhook: { path: "/hook" } },
+    };
+
+    const result = JSON.parse(sanitizeConfigForTransfer(JSON.stringify(input)));
+
+    expect(result.name).toBe("test");
+    expect(result.ingress.publicBaseUrl).toBe("");
+    expect(result.ingress.webhook).toEqual({ path: "/hook" });
+  });
+
+  test("handles config missing all target fields", () => {
+    const input = {
+      name: "test",
+      model: "claude-3",
+    };
+
+    const result = JSON.parse(sanitizeConfigForTransfer(JSON.stringify(input)));
+
+    expect(result.name).toBe("test");
+    expect(result.model).toBe("claude-3");
+  });
+
+  test("handles empty object", () => {
+    const result = sanitizeConfigForTransfer("{}");
+    expect(JSON.parse(result)).toEqual({});
+  });
+
+  test("handles invalid JSON by returning original string", () => {
+    const malformed = "{ not valid json }}}";
+    const result = sanitizeConfigForTransfer(malformed);
+    expect(result).toBe(malformed);
+  });
+
+  test("handles JSON null by returning original string", () => {
+    const result = sanitizeConfigForTransfer("null");
+    expect(result).toBe("null");
+  });
+
+  test("handles JSON array by returning original string", () => {
+    const result = sanitizeConfigForTransfer("[1, 2, 3]");
+    expect(result).toBe("[1, 2, 3]");
+  });
+
+  test("output uses 2-space indentation with trailing newline", () => {
+    const input = { name: "test" };
+    const result = sanitizeConfigForTransfer(JSON.stringify(input));
+
+    expect(result).toBe(JSON.stringify(input, null, 2) + "\n");
+    expect(result.endsWith("\n")).toBe(true);
+  });
+});