@vellumai/assistant 0.4.41 → 0.4.43

package/src/__tests__/avatar-e2e.test.ts

@@ -54,19 +54,35 @@ mock.module("../util/platform.js", () => ({
   getWorkspaceDir: () => mockWorkspaceDir,
 }));
 
-mock.module("../util/logger.js", () => ({
-  getLogger: () => ({
-    debug: () => {},
-    info: (...args: unknown[]) => {
-      logInfoCalls.push(args as [unknown, string]);
-    },
-    warn: (...args: unknown[]) => {
-      logWarnCalls.push(args as [unknown, string]);
-    },
-    error: (...args: unknown[]) => {
-      logErrorCalls.push(args as [unknown, string]);
-    },
-  }),
+mock.module("pino", () => {
+  function createLogger() {
+    return {
+      child: () => createLogger(),
+      debug: () => {},
+      info: (...args: unknown[]) => {
+        logInfoCalls.push(args as [unknown, string]);
+      },
+      warn: (...args: unknown[]) => {
+        logWarnCalls.push(args as [unknown, string]);
+      },
+      error: (...args: unknown[]) => {
+        logErrorCalls.push(args as [unknown, string]);
+      },
+    };
+  }
+
+  const pino = Object.assign(() => createLogger(), {
+    destination: () => ({ write: () => true }),
+    multistream: () => ({ write: () => true }),
+  });
+
+  return {
+    default: pino,
+  };
+});
+
+mock.module("pino-pretty", () => ({
+  default: () => ({ write: () => true }),
 }));
 
 mock.module("node:fs", () => ({
@@ -428,23 +444,27 @@ describe("avatar E2E integration", () => {
   // 9. Correlation ID propagation
   // -----------------------------------------------------------------------
 
-  test("managed success — correlation ID from response is logged", async () => {
+  test("managed success — correlation ID from response is propagated through the pipeline", async () => {
     mockStrategy = "managed_required";
     const response = managedPlatformResponse();
     response.correlation_id = "unique-corr-id-xyz";
     mockFetchReturning({ ok: true, status: 200, body: response });
 
-    await executeAvatar("a robot");
+    const result = await executeAvatar("a robot");
+
+    // The managed path succeeded and wrote the avatar file
+    expect(result.isError).toBe(false);
+    expect(writeFileSyncFn).toHaveBeenCalled();
 
-    // Look for the correlation ID in info log calls
-    const correlationLogged = logInfoCalls.some(([meta]) => {
-      if (meta && typeof meta === "object" && "correlationId" in meta) {
-        return (
-          (meta as { correlationId: string }).correlationId ===
-          "unique-corr-id-xyz"
-        );
+    const correlationLogged = logInfoCalls.some(([meta, message]) => {
+      if (message !== "Avatar saved successfully") return false;
+      if (!meta || typeof meta !== "object" || !("correlationId" in meta)) {
+        return false;
       }
-      return false;
+      return (
+        (meta as { correlationId?: unknown }).correlationId ===
+        "unique-corr-id-xyz"
+      );
     });
 
     expect(correlationLogged).toBe(true);

package/src/__tests__/browser-fill-credential.test.ts

@@ -76,7 +76,7 @@ mock.module("../tools/credentials/metadata-store.js", () => ({
   _setMetadataPath: () => {},
 }));
 
-import { executeBrowserFillCredential } from "../tools/browser/headless-browser.js";
+import { executeBrowserFillCredential } from "../tools/browser/browser-execution.js";
 import type { ToolContext } from "../tools/types.js";
 
 const ctx: ToolContext = {

package/src/__tests__/bundled-skill-retrieval-guard.test.ts

@@ -42,7 +42,7 @@ const GATEWAY_RETRIEVAL_BANLIST: Array<{
   {
     skillPath: "guardian-verify-setup/SKILL.md",
     bannedSnippets: [
-      'curl -s "$INTERNAL_GATEWAY_BASE_URL/v1/integrations/guardian/status',
+      'curl -s "$INTERNAL_GATEWAY_BASE_URL/v1/channel-verification-sessions/status',
     ],
   },
   {
@@ -51,12 +51,6 @@ const GATEWAY_RETRIEVAL_BANLIST: Array<{
       'curl -s "$INTERNAL_GATEWAY_BASE_URL/v1/integrations/telegram/config',
     ],
   },
-  {
-    skillPath: "sms-setup/SKILL.md",
-    bannedSnippets: [
-      'curl -s "$INTERNAL_GATEWAY_BASE_URL/v1/integrations/twilio/sms/compliance"',
-    ],
-  },
   {
     skillPath: "contacts/SKILL.md",
     bannedSnippets: [
@@ -82,9 +76,9 @@ const GATEWAY_RETRIEVAL_BANLIST: Array<{
   {
     skillPath: "public-ingress/SKILL.md",
     bannedSnippets: [
+      'curl -s "$INTERNAL_GATEWAY_BASE_URL/v1/',
       "security find-generic-password",
       "secret-tool lookup service vellum-assistant account credential:ngrok:authtoken",
-      "INTERNAL_GATEWAY_BASE_URL",
     ],
   },
   {
@@ -118,7 +112,6 @@ const HOST_BASH_RETRIEVAL_ALLOWLIST = new Set<string>([
 ]);
 
 const RETRIEVAL_MARKERS = [
-  "assistant integrations ",
   "assistant config get",
   "assistant email status",
   "assistant email inbox list",

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

@@ -82,9 +82,6 @@ mock.module("../calls/call-constants.js", () => ({
   getMaxCallDurationMs: () => 12 * 60 * 1000,
   getUserConsultationTimeoutMs: () => mockConsultationTimeoutMs,
   getSilenceTimeoutMs: () => mockSilenceTimeoutMs,
-  SILENCE_TIMEOUT_MS: 30_000,
-  MAX_CALL_DURATION_MS: 3600 * 1000,
-  USER_CONSULTATION_TIMEOUT_MS: 120 * 1000,
 }));
 
 // ── Voice session bridge mock ────────────────────────────────────────
@@ -166,7 +163,7 @@ import {
   getCanonicalGuardianRequest,
   getPendingCanonicalRequestByCallSessionId,
 } from "../memory/canonical-guardian-store.js";
-import { getMessages } from "../memory/conversation-store.js";
+import { getMessages } from "../memory/conversation-crud.js";
 import { getDb, initializeDb, resetDb, resetTestTables } from "../memory/db.js";
 import { conversations } from "../memory/schema.js";
 
@@ -871,7 +868,7 @@ describe("call-controller", () => {
 
   test("handleCallerUtterance: passes guardian context to startVoiceTurn", async () => {
     const trustCtx = {
-      sourceChannel: "voice" as const,
+      sourceChannel: "phone" as const,
       trustClass: "trusted_contact" as const,
       guardianExternalUserId: "+15550009999",
       guardianChatId: "+15550009999",
@@ -931,13 +928,12 @@ describe("call-controller", () => {
 
   test("setTrustContext: subsequent turns use updated guardian context", async () => {
     const initialCtx = {
-      sourceChannel: "voice" as const,
+      sourceChannel: "phone" as const,
       trustClass: "unknown" as const,
-      denialReason: "no_binding" as const,
     };
 
     const upgradedCtx = {
-      sourceChannel: "voice" as const,
+      sourceChannel: "phone" as const,
       trustClass: "guardian" as const,
       guardianExternalUserId: "+15550003333",
       guardianChatId: "+15550003333",

package/src/__tests__/call-conversation-messages.test.ts

@@ -33,7 +33,7 @@ import {
   recordCallEvent,
   updateCallSession,
 } from "../calls/call-store.js";
-import { getMessages } from "../memory/conversation-store.js";
+import { getMessages } from "../memory/conversation-crud.js";
 import { getDb, initializeDb, resetDb } from "../memory/db.js";
 import { conversations } from "../memory/schema.js";
 

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

@@ -4,6 +4,7 @@
  *
  * Validates:
  * - Strict implicit-default policy for caller identity.
+ * - Voice-ingress preflight blocks doomed outbound calls before Twilio dialing.
  * - Pointer messages are written on successful call start and on failure.
  */
 import { mkdtempSync, realpathSync, rmSync } from "node:fs";
@@ -35,6 +36,51 @@ mock.module("../util/logger.js", () => ({
 
 // Track whether the Twilio provider's initiateCall should succeed or throw
 let twilioInitiateCallBehavior: "success" | "error" = "success";
+let twilioInitiateCallCount = 0;
+let twilioInitiateCallArgs: Array<Record<string, unknown>> = [];
+let mockIngressEnabled = true;
+let mockIngressPublicBaseUrl = "https://test.example.com";
+
+interface MockGatewayHealthResult {
+  target: string;
+  healthy: boolean;
+  localDeployment: boolean;
+  error?: string;
+}
+
+interface MockEnsureLocalGatewayReadyResult extends MockGatewayHealthResult {
+  recovered: boolean;
+  recoveryAttempted: boolean;
+  recoverySkipped: boolean;
+}
+
+let probeLocalGatewayHealthResults: MockGatewayHealthResult[] = [];
+let probeLocalGatewayHealthCallCount = 0;
+let ensureLocalGatewayReadyResult: MockEnsureLocalGatewayReadyResult;
+let ensureLocalGatewayReadyCallCount = 0;
+
+function makeGatewayHealthResult(
+  overrides: Partial<MockGatewayHealthResult> = {},
+): MockGatewayHealthResult {
+  return {
+    target: "http://127.0.0.1:7830",
+    healthy: true,
+    localDeployment: true,
+    ...overrides,
+  };
+}
+
+function makeRecoveryResult(
+  overrides: Partial<MockEnsureLocalGatewayReadyResult> = {},
+): MockEnsureLocalGatewayReadyResult {
+  return {
+    ...makeGatewayHealthResult(),
+    recovered: false,
+    recoveryAttempted: false,
+    recoverySkipped: false,
+    ...overrides,
+  };
+}
 
 mock.module("../calls/twilio-config.js", () => ({
   getTwilioConfig: (assistantId?: string) => ({
@@ -55,11 +101,16 @@ mock.module("../calls/twilio-provider.js", () => ({
         reason: `${number} is not eligible as a caller ID`,
       };
     }
-    async initiateCall() {
+    async initiateCall(args: Record<string, unknown>) {
+      twilioInitiateCallCount++;
+      twilioInitiateCallArgs.push(args);
       if (twilioInitiateCallBehavior === "error")
         throw new Error("Twilio unavailable");
       return { callSid: "CA_test_123" };
     }
+    async endCall() {
+      return;
+    }
   },
 }));
 
@@ -74,6 +125,10 @@ mock.module("../config/loader.js", () => ({
       provider: "twilio",
       callerIdentity: { allowPerCallOverride: true },
     },
+    ingress: {
+      enabled: mockIngressEnabled,
+      publicBaseUrl: mockIngressPublicBaseUrl,
+    },
     memory: { enabled: false },
   }),
   getConfig: () => ({
@@ -82,12 +137,17 @@ mock.module("../config/loader.js", () => ({
       provider: "twilio",
       callerIdentity: { allowPerCallOverride: true },
     },
+    ingress: {
+      enabled: mockIngressEnabled,
+      publicBaseUrl: mockIngressPublicBaseUrl,
+    },
     memory: { enabled: false },
   }),
 }));
 
 mock.module("../inbound/platform-callback-registration.js", () => ({
   resolveCallbackUrl: async (fn: () => string) => fn(),
+  shouldUsePlatformCallbacks: () => false,
 }));
 
 mock.module("../inbound/public-ingress-urls.js", () => ({
@@ -101,14 +161,59 @@ mock.module("../memory/conversation-title-service.js", () => ({
   queueGenerateConversationTitle: () => {},
 }));
 
-import { resolveCallerIdentity, startCall } from "../calls/call-domain.js";
+mock.module("../runtime/local-gateway-health.js", () => ({
+  probeLocalGatewayHealth: async () => {
+    probeLocalGatewayHealthCallCount++;
+    const next =
+      probeLocalGatewayHealthResults.shift() ?? makeGatewayHealthResult();
+    return next;
+  },
+  ensureLocalGatewayReady: async () => {
+    ensureLocalGatewayReadyCallCount++;
+    return ensureLocalGatewayReadyResult;
+  },
+}));
+
+mock.module("../daemon/handlers/config-ingress.js", () => ({
+  computeGatewayTarget: () => "http://127.0.0.1:7830",
+  handleIngressConfig: async () => {},
+  syncTwilioWebhooks: async () => ({ success: true }),
+}));
+
+import {
+  clearActiveCallLeases,
+  getActiveCallLease,
+  listActiveCallLeases,
+} from "../calls/active-call-lease.js";
+import {
+  cancelCall,
+  resolveCallerIdentity,
+  startCall,
+} from "../calls/call-domain.js";
 import type { AssistantConfig } from "../config/types.js";
-import { getMessages } from "../memory/conversation-store.js";
+import { getMessages } from "../memory/conversation-crud.js";
 import { getDb, initializeDb, resetDb } from "../memory/db.js";
 import { conversations } from "../memory/schema.js";
 
 initializeDb();
 
+beforeEach(() => {
+  resetTables();
+  clearActiveCallLeases();
+  twilioInitiateCallBehavior = "success";
+  twilioInitiateCallCount = 0;
+  twilioInitiateCallArgs = [];
+  mockIngressEnabled = true;
+  mockIngressPublicBaseUrl = "https://test.example.com";
+  probeLocalGatewayHealthResults = [
+    makeGatewayHealthResult(),
+    makeGatewayHealthResult(),
+  ];
+  probeLocalGatewayHealthCallCount = 0;
+  ensureLocalGatewayReadyResult = makeRecoveryResult();
+  ensureLocalGatewayReadyCallCount = 0;
+});
+
 let ensuredConvIds = new Set<string>();
 function ensureConversation(id: string): void {
   if (ensuredConvIds.has(id)) return;
@@ -288,11 +393,6 @@ describe("resolveCallerIdentity — strict implicit-default policy", () => {
 // ── Pointer message regression tests ──────────────────────────────
 
 describe("startCall — pointer message regression", () => {
-  beforeEach(() => {
-    resetTables();
-    twilioInitiateCallBehavior = "success";
-  });
-
   test("successful call writes a started pointer to the initiating conversation", async () => {
     const convId = "conv-domain-ptr-start";
     ensureConversation(convId);
@@ -304,6 +404,24 @@ describe("startCall — pointer message regression", () => {
     });
 
     expect(result.ok).toBe(true);
+    expect(twilioInitiateCallCount).toBe(1);
+    expect(twilioInitiateCallArgs).toEqual([
+      {
+        from: "+15550001111",
+        to: "+15559876543",
+        webhookUrl: "https://test.example.com/webhooks/twilio/voice/test",
+        statusCallbackUrl: "https://test.example.com/webhooks/twilio/status",
+      },
+    ]);
+    // Gateway reconcile triggers have been removed; the gateway reads
+    // credentials and config via TTL caches.
+    if (result.ok) {
+      expect(getActiveCallLease(result.session.id)).toEqual({
+        callSessionId: result.session.id,
+        providerCallSid: "CA_test_123",
+        updatedAt: expect.any(Number),
+      });
+    }
     // Allow async pointer write to flush
     await new Promise((r) => setTimeout(r, 50));
 
@@ -313,6 +431,102 @@ describe("startCall — pointer message regression", () => {
     expect(text!).toContain("started");
   });
 
+  test("fails fast when ingress is disabled and never reaches Twilio dialing", async () => {
+    const convId = "conv-domain-ingress-disabled";
+    ensureConversation(convId);
+    mockIngressEnabled = false;
+
+    const result = await startCall({
+      phoneNumber: "+15559876543",
+      task: "Test call",
+      conversationId: convId,
+    });
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.status).toBe(503);
+      expect(result.error).toContain("Public ingress");
+    }
+    expect(probeLocalGatewayHealthCallCount).toBe(0);
+    expect(ensureLocalGatewayReadyCallCount).toBe(0);
+    // No reconcile calls expected (reconcile triggers removed).
+    expect(twilioInitiateCallCount).toBe(0);
+
+    await new Promise((r) => setTimeout(r, 50));
+
+    const text = getLatestAssistantText(convId);
+    expect(text).not.toBeNull();
+    expect(text!).toContain("+15559876543");
+    expect(text!).toContain("failed");
+  });
+
+  test("never dials Twilio when the local callback gateway stays unhealthy", async () => {
+    const convId = "conv-domain-preflight-unhealthy";
+    ensureConversation(convId);
+    probeLocalGatewayHealthResults = [
+      makeGatewayHealthResult({
+        healthy: false,
+        error: "Gateway health check returned HTTP 503",
+      }),
+      makeGatewayHealthResult({
+        healthy: false,
+        error: "Gateway health check returned HTTP 503",
+      }),
+    ];
+    ensureLocalGatewayReadyResult = makeRecoveryResult({
+      healthy: false,
+      error: "Gateway health check returned HTTP 503",
+      recovered: false,
+      recoveryAttempted: true,
+    });
+
+    const result = await startCall({
+      phoneNumber: "+15559876543",
+      task: "Test call",
+      conversationId: convId,
+    });
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.status).toBe(503);
+      expect(result.error).toContain("still unhealthy");
+    }
+    expect(probeLocalGatewayHealthCallCount).toBe(2);
+    expect(ensureLocalGatewayReadyCallCount).toBe(1);
+    // No reconcile calls expected (reconcile triggers removed).
+    expect(twilioInitiateCallCount).toBe(0);
+  });
+
+  test("can recover a local gateway and then place exactly one outbound Twilio call", async () => {
+    const convId = "conv-domain-preflight-recovery";
+    ensureConversation(convId);
+    probeLocalGatewayHealthResults = [
+      makeGatewayHealthResult({
+        healthy: false,
+        error: "Gateway health check returned HTTP 503",
+      }),
+      makeGatewayHealthResult(),
+    ];
+    ensureLocalGatewayReadyResult = makeRecoveryResult({
+      healthy: true,
+      recovered: true,
+      recoveryAttempted: true,
+    });
+
+    const result = await startCall({
+      phoneNumber: "+15559876543",
+      task: "Test call",
+      conversationId: convId,
+    });
+
+    expect(result.ok).toBe(true);
+    expect(probeLocalGatewayHealthCallCount).toBe(2);
+    expect(ensureLocalGatewayReadyCallCount).toBe(1);
+    // Gateway reconcile triggers have been removed; the gateway reads
+    // credentials and config via TTL caches.
+    expect(twilioInitiateCallCount).toBe(1);
+  });
+
   test("failed call writes a failed pointer to the initiating conversation", async () => {
     const convId = "conv-domain-ptr-fail";
     ensureConversation(convId);
@@ -325,6 +539,8 @@ describe("startCall — pointer message regression", () => {
     });
 
     expect(result.ok).toBe(false);
+    expect(twilioInitiateCallCount).toBe(1);
+    expect(listActiveCallLeases()).toHaveLength(0);
     // Allow async pointer write to flush
     await new Promise((r) => setTimeout(r, 50));
 
@@ -333,4 +549,30 @@ describe("startCall — pointer message regression", () => {
     expect(text!).toContain("+15559876543");
     expect(text!).toContain("failed");
   });
+
+  test("canceling an active call releases its persisted keepalive lease", async () => {
+    const convId = "conv-domain-cancel-releases-lease";
+    ensureConversation(convId);
+
+    const startResult = await startCall({
+      phoneNumber: "+15559876543",
+      task: "Test call",
+      conversationId: convId,
+    });
+
+    expect(startResult.ok).toBe(true);
+    if (!startResult.ok) {
+      return;
+    }
+
+    expect(getActiveCallLease(startResult.session.id)).not.toBeNull();
+
+    const cancelResult = await cancelCall({
+      callSessionId: startResult.session.id,
+      reason: "User requested",
+    });
+
+    expect(cancelResult.ok).toBe(true);
+    expect(getActiveCallLease(startResult.session.id)).toBeNull();
+  });
 });

package/src/__tests__/call-pointer-message-composer.test.ts

@@ -74,36 +74,36 @@ describe("getPointerFallbackMessage", () => {
     expect(msg).toContain("failed: no answer");
   });
 
-  test("guardian_verification_succeeded defaults to voice channel", () => {
+  test("verification_succeeded defaults to phone channel", () => {
     const msg = getPointerFallbackMessage({
-      scenario: "guardian_verification_succeeded",
+      scenario: "verification_succeeded",
       phoneNumber: "+15559876543",
     });
-    expect(msg).toContain("Guardian verification (voice)");
+    expect(msg).toContain("Guardian verification (phone)");
     expect(msg).toContain("succeeded");
   });
 
-  test("guardian_verification_succeeded with custom channel", () => {
+  test("verification_succeeded with explicit phone channel", () => {
     const msg = getPointerFallbackMessage({
-      scenario: "guardian_verification_succeeded",
+      scenario: "verification_succeeded",
       phoneNumber: "+15559876543",
-      channel: "sms",
+      channel: "phone",
     });
-    expect(msg).toContain("Guardian verification (sms)");
+    expect(msg).toContain("Guardian verification (phone)");
   });
 
-  test("guardian_verification_failed without reason", () => {
+  test("verification_failed without reason", () => {
     const msg = getPointerFallbackMessage({
-      scenario: "guardian_verification_failed",
+      scenario: "verification_failed",
       phoneNumber: "+15559876543",
     });
     expect(msg).toContain("Guardian verification");
     expect(msg).toContain("failed");
   });
 
-  test("guardian_verification_failed with reason", () => {
+  test("verification_failed with reason", () => {
     const msg = getPointerFallbackMessage({
-      scenario: "guardian_verification_failed",
+      scenario: "verification_failed",
       phoneNumber: "+15559876543",
       reason: "Max attempts exceeded",
     });
@@ -159,12 +159,12 @@ describe("buildPointerInstruction", () => {
 
   test("includes channel when provided", () => {
     const ctx: CallPointerMessageContext = {
-      scenario: "guardian_verification_succeeded",
+      scenario: "verification_succeeded",
       phoneNumber: "+15559876543",
-      channel: "sms",
+      channel: "phone",
     };
     const instruction = buildPointerInstruction(ctx);
-    expect(instruction).toContain("Channel: sms");
+    expect(instruction).toContain("Channel: phone");
   });
 
   test("omits optional fields when not provided", () => {

package/src/__tests__/call-pointer-messages.test.ts

@@ -38,7 +38,7 @@ import {
   resetPointerMessageProcessor,
   setPointerMessageProcessor,
 } from "../calls/call-pointer-messages.js";
-import { addMessage, getMessages } from "../memory/conversation-store.js";
+import { addMessage, getMessages } from "../memory/conversation-crud.js";
 import { getDb, initializeDb, resetDb } from "../memory/db.js";
 import { conversations } from "../memory/schema.js";
 
@@ -201,34 +201,30 @@ describe("addPointerMessage", () => {
     expect(text).toContain("failed: no answer");
   });
 
-  test("adds a guardian_verification_succeeded pointer message", () => {
+  test("adds a verification_succeeded pointer message", () => {
     const convId = "conv-ptr-gv-success";
     ensureConversation(convId);
-    addPointerMessage(
-      convId,
-      "guardian_verification_succeeded",
-      "+15559876543",
-    );
+    addPointerMessage(convId, "verification_succeeded", "+15559876543");
     const text = getLatestAssistantText(convId);
     expect(text).toContain("Guardian verification");
     expect(text).toContain("+15559876543");
     expect(text).toContain("succeeded");
   });
 
-  test("adds a guardian_verification_failed pointer message without reason", () => {
+  test("adds a verification_failed pointer message without reason", () => {
     const convId = "conv-ptr-gv-fail";
     ensureConversation(convId);
-    addPointerMessage(convId, "guardian_verification_failed", "+15559876543");
+    addPointerMessage(convId, "verification_failed", "+15559876543");
     const text = getLatestAssistantText(convId);
     expect(text).toContain("Guardian verification");
     expect(text).toContain("+15559876543");
     expect(text).toContain("failed");
   });
 
-  test("adds a guardian_verification_failed pointer message with reason", () => {
+  test("adds a verification_failed pointer message with reason", () => {
     const convId = "conv-ptr-gv-fail-r";
     ensureConversation(convId);
-    addPointerMessage(convId, "guardian_verification_failed", "+15559876543", {
+    addPointerMessage(convId, "verification_failed", "+15559876543", {
       reason: "Max attempts exceeded",
     });
     const text = getLatestAssistantText(convId);