@vellumai/assistant 0.3.4 → 0.3.6

package/src/__tests__/handlers-twilio-config.test.ts

@@ -523,6 +523,54 @@ describe('Twilio config handler', () => {
     }
   });
 
+  test('getTwilioConfig with assistantId prefers assistant-scoped mapping over global phone number', () => {
+    secureKeyStore['credential:twilio:account_sid'] = 'AC1234567890abcdef1234567890abcdef';
+    secureKeyStore['credential:twilio:auth_token'] = 'test_auth_token';
+    rawConfigStore = {
+      sms: {
+        phoneNumber: '+15551234567',
+        assistantPhoneNumbers: {
+          'ast-alpha': '+15550000001',
+        },
+      },
+      ingress: { enabled: true, publicBaseUrl: 'https://test.ngrok.io' },
+    };
+
+    const savedEnv = process.env.TWILIO_PHONE_NUMBER;
+    delete process.env.TWILIO_PHONE_NUMBER;
+
+    try {
+      const config = getTwilioConfig('ast-alpha');
+      expect(config.phoneNumber).toBe('+15550000001');
+    } finally {
+      if (savedEnv !== undefined) process.env.TWILIO_PHONE_NUMBER = savedEnv;
+    }
+  });
+
+  test('getTwilioConfig with assistantId falls back to global number when mapping is missing', () => {
+    secureKeyStore['credential:twilio:account_sid'] = 'AC1234567890abcdef1234567890abcdef';
+    secureKeyStore['credential:twilio:auth_token'] = 'test_auth_token';
+    rawConfigStore = {
+      sms: {
+        phoneNumber: '+15551234567',
+        assistantPhoneNumbers: {
+          'ast-alpha': '+15550000001',
+        },
+      },
+      ingress: { enabled: true, publicBaseUrl: 'https://test.ngrok.io' },
+    };
+
+    const savedEnv = process.env.TWILIO_PHONE_NUMBER;
+    delete process.env.TWILIO_PHONE_NUMBER;
+
+    try {
+      const config = getTwilioConfig('ast-beta');
+      expect(config.phoneNumber).toBe('+15551234567');
+    } finally {
+      if (savedEnv !== undefined) process.env.TWILIO_PHONE_NUMBER = savedEnv;
+    }
+  });
+
   // ── assign_number ───────────────────────────────────────────────────
 
   test('assign_number persists phone number to config', async () => {
@@ -1389,4 +1437,489 @@ describe('Twilio config handler', () => {
     expect(responseStr).not.toContain('AC_secret_account_sid_12345');
     expect(responseStr).not.toContain('secret_auth_token_67890');
   });
+
+  // ── sms_compliance_status ───────────────────────────────────────────
+
+  test('sms_compliance_status returns structured compliance data for toll-free number', async () => {
+    secureKeyStore['credential:twilio:account_sid'] = 'AC1234567890abcdef1234567890abcdef';
+    secureKeyStore['credential:twilio:auth_token'] = 'test_auth_token';
+    rawConfigStore = { sms: { phoneNumber: '+18001234567' } };
+
+    globalThis.fetch = (async (url: string | URL | Request) => {
+      const urlStr = typeof url === 'string' ? url : url instanceof URL ? url.toString() : url.url;
+      // Phone number SID lookup
+      if (urlStr.includes('IncomingPhoneNumbers.json') && urlStr.includes('PhoneNumber=')) {
+        return new Response(JSON.stringify({
+          incoming_phone_numbers: [{ sid: 'PN123abc', phone_number: '+18001234567' }],
+        }), { status: 200 });
+      }
+      // Toll-free verification lookup
+      if (urlStr.includes('Tollfree/Verifications')) {
+        return new Response(JSON.stringify({
+          verifications: [{
+            sid: 'TF_VER_001',
+            status: 'TWILIO_APPROVED',
+            rejection_reason: null,
+            edit_allowed: false,
+          }],
+        }), { status: 200 });
+      }
+      return originalFetch(url);
+    }) as typeof fetch;
+
+    const msg: TwilioConfigRequest = {
+      type: 'twilio_config',
+      action: 'sms_compliance_status',
+    };
+
+    const { ctx, sent } = createTestContext();
+    await handleTwilioConfig(msg, {} as net.Socket, ctx);
+
+    expect(sent).toHaveLength(1);
+    const res = sent[0] as { type: string; success: boolean; compliance?: Record<string, unknown> };
+    expect(res.success).toBe(true);
+    expect(res.compliance).toBeDefined();
+    expect(res.compliance!.numberType).toBe('toll_free');
+    expect(res.compliance!.verificationSid).toBe('TF_VER_001');
+    expect(res.compliance!.verificationStatus).toBe('TWILIO_APPROVED');
+  });
+
+  test('sms_compliance_status returns local_10dlc type for non-toll-free number without remote check', async () => {
+    secureKeyStore['credential:twilio:account_sid'] = 'AC1234567890abcdef1234567890abcdef';
+    secureKeyStore['credential:twilio:auth_token'] = 'test_auth_token';
+    rawConfigStore = { sms: { phoneNumber: '+15551234567' } };
+
+    const msg: TwilioConfigRequest = {
+      type: 'twilio_config',
+      action: 'sms_compliance_status',
+    };
+
+    const { ctx, sent } = createTestContext();
+    await handleTwilioConfig(msg, {} as net.Socket, ctx);
+
+    expect(sent).toHaveLength(1);
+    const res = sent[0] as { type: string; success: boolean; compliance?: Record<string, unknown> };
+    expect(res.success).toBe(true);
+    expect(res.compliance).toBeDefined();
+    expect(res.compliance!.numberType).toBe('local_10dlc');
+    // No verification fields for non-toll-free
+    expect(res.compliance!.verificationSid).toBeUndefined();
+  });
+
+  test('sms_compliance_status returns error when no credentials', async () => {
+    const msg: TwilioConfigRequest = {
+      type: 'twilio_config',
+      action: 'sms_compliance_status',
+    };
+
+    const { ctx, sent } = createTestContext();
+    await handleTwilioConfig(msg, {} as net.Socket, ctx);
+
+    expect(sent).toHaveLength(1);
+    const res = sent[0] as { type: string; success: boolean; error?: string };
+    expect(res.success).toBe(false);
+    expect(res.error).toContain('Twilio credentials not configured');
+  });
+
+  // ── sms_submit_tollfree_verification ────────────────────────────────
+
+  test('sms_submit_tollfree_verification validates required fields', async () => {
+    secureKeyStore['credential:twilio:account_sid'] = 'AC1234567890abcdef1234567890abcdef';
+    secureKeyStore['credential:twilio:auth_token'] = 'test_auth_token';
+
+    const msg: TwilioConfigRequest = {
+      type: 'twilio_config',
+      action: 'sms_submit_tollfree_verification',
+      verificationParams: {
+        // Missing all required fields
+        businessName: 'Test Biz',
+      },
+    };
+
+    const { ctx, sent } = createTestContext();
+    await handleTwilioConfig(msg, {} as net.Socket, ctx);
+
+    expect(sent).toHaveLength(1);
+    const res = sent[0] as { type: string; success: boolean; error?: string };
+    expect(res.success).toBe(false);
+    expect(res.error).toContain('Missing required verification fields');
+    expect(res.error).toContain('tollfreePhoneNumberSid');
+  });
+
+  test('sms_submit_tollfree_verification defaults businessType to SOLE_PROPRIETOR', async () => {
+    secureKeyStore['credential:twilio:account_sid'] = 'AC1234567890abcdef1234567890abcdef';
+    secureKeyStore['credential:twilio:auth_token'] = 'test_auth_token';
+
+    let capturedBody = '';
+    globalThis.fetch = (async (url: string | URL | Request, init?: RequestInit) => {
+      const urlStr = typeof url === 'string' ? url : url instanceof URL ? url.toString() : url.url;
+      if (urlStr.includes('Tollfree/Verifications') && init?.method === 'POST') {
+        capturedBody = init?.body?.toString() ?? '';
+        return new Response(JSON.stringify({
+          sid: 'TF_VER_NEW',
+          status: 'PENDING_REVIEW',
+        }), { status: 201 });
+      }
+      return originalFetch(url);
+    }) as typeof fetch;
+
+    const msg: TwilioConfigRequest = {
+      type: 'twilio_config',
+      action: 'sms_submit_tollfree_verification',
+      verificationParams: {
+        tollfreePhoneNumberSid: 'PN123',
+        businessName: 'Test Biz',
+        businessWebsite: 'https://test.com',
+        notificationEmail: 'test@test.com',
+        useCaseCategories: ['CUSTOMER_CARE'],
+        useCaseSummary: 'Customer support messages',
+        productionMessageSample: 'Your order has shipped!',
+        optInImageUrls: ['https://test.com/optin.png'],
+        optInType: 'WEB_FORM',
+        messageVolume: '100',
+        // businessType NOT provided — should default to SOLE_PROPRIETOR
+      },
+    };
+
+    const { ctx, sent } = createTestContext();
+    await handleTwilioConfig(msg, {} as net.Socket, ctx);
+
+    expect(sent).toHaveLength(1);
+    const res = sent[0] as { type: string; success: boolean; compliance?: Record<string, unknown> };
+    expect(res.success).toBe(true);
+    expect(res.compliance).toBeDefined();
+    expect(res.compliance!.verificationSid).toBe('TF_VER_NEW');
+    expect(res.compliance!.verificationStatus).toBe('PENDING_REVIEW');
+
+    // Verify the default businessType was sent to Twilio
+    expect(capturedBody).toContain('BusinessType=SOLE_PROPRIETOR');
+  });
+
+  test('sms_submit_tollfree_verification accepts current Twilio enum ACCOUNT_NOTIFICATIONS', async () => {
+    secureKeyStore['credential:twilio:account_sid'] = 'AC1234567890abcdef1234567890abcdef';
+    secureKeyStore['credential:twilio:auth_token'] = 'test_auth_token';
+
+    let capturedBody = '';
+    globalThis.fetch = (async (url: string | URL | Request, init?: RequestInit) => {
+      const urlStr = typeof url === 'string' ? url : url instanceof URL ? url.toString() : url.url;
+      if (urlStr.includes('Tollfree/Verifications') && init?.method === 'POST') {
+        capturedBody = init?.body?.toString() ?? '';
+        return new Response(JSON.stringify({
+          sid: 'TF_VER_NEW',
+          status: 'PENDING_REVIEW',
+        }), { status: 201 });
+      }
+      return originalFetch(url);
+    }) as typeof fetch;
+
+    const msg: TwilioConfigRequest = {
+      type: 'twilio_config',
+      action: 'sms_submit_tollfree_verification',
+      verificationParams: {
+        tollfreePhoneNumberSid: 'PN123',
+        businessName: 'Test Biz',
+        businessWebsite: 'https://test.com',
+        notificationEmail: 'test@test.com',
+        useCaseCategories: ['ACCOUNT_NOTIFICATIONS'],
+        useCaseSummary: 'Account alerts',
+        productionMessageSample: 'Your account was updated',
+        optInImageUrls: ['https://test.com/optin.png'],
+        optInType: 'WEB_FORM',
+        messageVolume: '100',
+      },
+    };
+
+    const { ctx, sent } = createTestContext();
+    await handleTwilioConfig(msg, {} as net.Socket, ctx);
+
+    expect(sent).toHaveLength(1);
+    const res = sent[0] as { success: boolean };
+    expect(res.success).toBe(true);
+    expect(capturedBody).toContain('UseCaseCategories=ACCOUNT_NOTIFICATIONS');
+  });
+
+  test('sms_submit_tollfree_verification rejects invalid useCaseCategories', async () => {
+    secureKeyStore['credential:twilio:account_sid'] = 'AC1234567890abcdef1234567890abcdef';
+    secureKeyStore['credential:twilio:auth_token'] = 'test_auth_token';
+
+    const msg: TwilioConfigRequest = {
+      type: 'twilio_config',
+      action: 'sms_submit_tollfree_verification',
+      verificationParams: {
+        tollfreePhoneNumberSid: 'PN123',
+        businessName: 'Test Biz',
+        businessWebsite: 'https://test.com',
+        notificationEmail: 'test@test.com',
+        useCaseCategories: ['INVALID_CATEGORY'],
+        useCaseSummary: 'Test',
+        productionMessageSample: 'Test message',
+        optInImageUrls: ['https://test.com/optin.png'],
+        optInType: 'WEB_FORM',
+        messageVolume: '100',
+      },
+    };
+
+    const { ctx, sent } = createTestContext();
+    await handleTwilioConfig(msg, {} as net.Socket, ctx);
+
+    expect(sent).toHaveLength(1);
+    const res = sent[0] as { type: string; success: boolean; error?: string };
+    expect(res.success).toBe(false);
+    expect(res.error).toContain('Invalid useCaseCategories');
+    expect(res.error).toContain('INVALID_CATEGORY');
+  });
+
+  test('sms_submit_tollfree_verification returns error without verificationParams', async () => {
+    secureKeyStore['credential:twilio:account_sid'] = 'AC1234567890abcdef1234567890abcdef';
+    secureKeyStore['credential:twilio:auth_token'] = 'test_auth_token';
+
+    const msg: TwilioConfigRequest = {
+      type: 'twilio_config',
+      action: 'sms_submit_tollfree_verification',
+    };
+
+    const { ctx, sent } = createTestContext();
+    await handleTwilioConfig(msg, {} as net.Socket, ctx);
+
+    expect(sent).toHaveLength(1);
+    const res = sent[0] as { type: string; success: boolean; error?: string };
+    expect(res.success).toBe(false);
+    expect(res.error).toContain('verificationParams is required');
+  });
+
+  // ── release_number ─────────────────────────────────────────────────
+
+  test('release_number clears config and secure keys', async () => {
+    secureKeyStore['credential:twilio:account_sid'] = 'AC1234567890abcdef1234567890abcdef';
+    secureKeyStore['credential:twilio:auth_token'] = 'test_auth_token';
+    secureKeyStore['credential:twilio:phone_number'] = '+15551234567';
+    rawConfigStore = {
+      sms: {
+        phoneNumber: '+15551234567',
+        assistantPhoneNumbers: { 'ast-alpha': '+15551234567' },
+      },
+    };
+
+    globalThis.fetch = (async (url: string | URL | Request, init?: RequestInit) => {
+      const urlStr = typeof url === 'string' ? url : url instanceof URL ? url.toString() : url.url;
+      // Phone number SID lookup
+      if (urlStr.includes('IncomingPhoneNumbers.json') && urlStr.includes('PhoneNumber=')) {
+        return new Response(JSON.stringify({
+          incoming_phone_numbers: [{ sid: 'PN123abc', phone_number: '+15551234567' }],
+        }), { status: 200 });
+      }
+      // Phone number deletion
+      if (urlStr.includes('IncomingPhoneNumbers/PN123abc.json') && init?.method === 'DELETE') {
+        return new Response('', { status: 204 });
+      }
+      return originalFetch(url);
+    }) as typeof fetch;
+
+    const msg: TwilioConfigRequest = {
+      type: 'twilio_config',
+      action: 'release_number',
+    };
+
+    const { ctx, sent } = createTestContext();
+    await handleTwilioConfig(msg, {} as net.Socket, ctx);
+
+    expect(sent).toHaveLength(1);
+    const res = sent[0] as { type: string; success: boolean; warning?: string };
+    expect(res.success).toBe(true);
+    expect(res.warning).toContain('Phone number released');
+
+    // Verify config was cleared
+    const sms = rawConfigStore.sms as Record<string, unknown>;
+    expect(sms.phoneNumber).toBeUndefined();
+    expect(sms.assistantPhoneNumbers).toBeUndefined();
+
+    // Verify secure key was cleared
+    expect(secureKeyStore['credential:twilio:phone_number']).toBeUndefined();
+  });
+
+  test('release_number returns error when no credentials', async () => {
+    rawConfigStore = { sms: { phoneNumber: '+15551234567' } };
+
+    const msg: TwilioConfigRequest = {
+      type: 'twilio_config',
+      action: 'release_number',
+    };
+
+    const { ctx, sent } = createTestContext();
+    await handleTwilioConfig(msg, {} as net.Socket, ctx);
+
+    expect(sent).toHaveLength(1);
+    const res = sent[0] as { type: string; success: boolean; error?: string };
+    expect(res.success).toBe(false);
+    expect(res.error).toContain('Twilio credentials not configured');
+  });
+
+  test('release_number returns error when no phone number assigned', async () => {
+    secureKeyStore['credential:twilio:account_sid'] = 'AC1234567890abcdef1234567890abcdef';
+    secureKeyStore['credential:twilio:auth_token'] = 'test_auth_token';
+    rawConfigStore = {};
+
+    const msg: TwilioConfigRequest = {
+      type: 'twilio_config',
+      action: 'release_number',
+    };
+
+    const { ctx, sent } = createTestContext();
+    await handleTwilioConfig(msg, {} as net.Socket, ctx);
+
+    expect(sent).toHaveLength(1);
+    const res = sent[0] as { type: string; success: boolean; error?: string };
+    expect(res.success).toBe(false);
+    expect(res.error).toContain('No phone number to release');
+  });
+
+  // ── sms_delete_tollfree_verification ────────────────────────────────
+
+  test('sms_delete_tollfree_verification requires verificationSid', async () => {
+    secureKeyStore['credential:twilio:account_sid'] = 'AC1234567890abcdef1234567890abcdef';
+    secureKeyStore['credential:twilio:auth_token'] = 'test_auth_token';
+
+    const msg: TwilioConfigRequest = {
+      type: 'twilio_config',
+      action: 'sms_delete_tollfree_verification',
+    };
+
+    const { ctx, sent } = createTestContext();
+    await handleTwilioConfig(msg, {} as net.Socket, ctx);
+
+    expect(sent).toHaveLength(1);
+    const res = sent[0] as { type: string; success: boolean; error?: string };
+    expect(res.success).toBe(false);
+    expect(res.error).toContain('verificationSid is required');
+  });
+
+  test('sms_delete_tollfree_verification includes queue warning', async () => {
+    secureKeyStore['credential:twilio:account_sid'] = 'AC1234567890abcdef1234567890abcdef';
+    secureKeyStore['credential:twilio:auth_token'] = 'test_auth_token';
+
+    globalThis.fetch = (async (url: string | URL | Request, init?: RequestInit) => {
+      const urlStr = typeof url === 'string' ? url : url instanceof URL ? url.toString() : url.url;
+      if (urlStr.includes('Tollfree/Verifications/TF_VER_001') && init?.method === 'DELETE') {
+        return new Response('', { status: 204 });
+      }
+      return originalFetch(url);
+    }) as typeof fetch;
+
+    const msg: TwilioConfigRequest = {
+      type: 'twilio_config',
+      action: 'sms_delete_tollfree_verification',
+      verificationSid: 'TF_VER_001',
+    };
+
+    const { ctx, sent } = createTestContext();
+    await handleTwilioConfig(msg, {} as net.Socket, ctx);
+
+    expect(sent).toHaveLength(1);
+    const res = sent[0] as { type: string; success: boolean; warning?: string };
+    expect(res.success).toBe(true);
+    expect(res.warning).toContain('review queue');
+  });
+
+  // ── sms_update_tollfree_verification ────────────────────────────────
+
+  test('sms_update_tollfree_verification requires verificationSid', async () => {
+    secureKeyStore['credential:twilio:account_sid'] = 'AC1234567890abcdef1234567890abcdef';
+    secureKeyStore['credential:twilio:auth_token'] = 'test_auth_token';
+
+    const msg: TwilioConfigRequest = {
+      type: 'twilio_config',
+      action: 'sms_update_tollfree_verification',
+    };
+
+    const { ctx, sent } = createTestContext();
+    await handleTwilioConfig(msg, {} as net.Socket, ctx);
+
+    expect(sent).toHaveLength(1);
+    const res = sent[0] as { type: string; success: boolean; error?: string };
+    expect(res.success).toBe(false);
+    expect(res.error).toContain('verificationSid is required');
+  });
+
+  test('sms_update_tollfree_verification blocks updates when rejected verification is not editable', async () => {
+    secureKeyStore['credential:twilio:account_sid'] = 'AC1234567890abcdef1234567890abcdef';
+    secureKeyStore['credential:twilio:auth_token'] = 'test_auth_token';
+
+    let attemptedUpdate = false;
+    globalThis.fetch = (async (url: string | URL | Request, init?: RequestInit) => {
+      const urlStr = typeof url === 'string' ? url : url instanceof URL ? url.toString() : url.url;
+      if (urlStr.includes('Tollfree/Verifications/TF_VER_001') && init?.method === 'GET') {
+        return new Response(JSON.stringify({
+          sid: 'TF_VER_001',
+          status: 'TWILIO_REJECTED',
+          edit_allowed: false,
+          edit_expiration: '2026-01-01T00:00:00Z',
+        }), { status: 200 });
+      }
+      if (urlStr.includes('Tollfree/Verifications/TF_VER_001') && init?.method === 'POST') {
+        attemptedUpdate = true;
+        return new Response(JSON.stringify({
+          sid: 'TF_VER_001',
+          status: 'IN_REVIEW',
+        }), { status: 200 });
+      }
+      return originalFetch(url);
+    }) as typeof fetch;
+
+    const msg: TwilioConfigRequest = {
+      type: 'twilio_config',
+      action: 'sms_update_tollfree_verification',
+      verificationSid: 'TF_VER_001',
+      verificationParams: { useCaseSummary: 'Updated summary' },
+    };
+
+    const { ctx, sent } = createTestContext();
+    await handleTwilioConfig(msg, {} as net.Socket, ctx);
+
+    expect(sent).toHaveLength(1);
+    const res = sent[0] as { success: boolean; error?: string; compliance?: Record<string, unknown> };
+    expect(res.success).toBe(false);
+    expect(res.error).toContain('cannot be updated');
+    expect(res.compliance?.editAllowed).toBe(false);
+    expect(attemptedUpdate).toBe(false);
+  });
+
+  test('sms_doctor resolves toll-free verification using phone SID lookup', async () => {
+    secureKeyStore['credential:twilio:account_sid'] = 'AC1234567890abcdef1234567890abcdef';
+    secureKeyStore['credential:twilio:auth_token'] = 'test_auth_token';
+    rawConfigStore = { sms: { phoneNumber: '+18001234567' } };
+
+    let verificationLookupUrl = '';
+    globalThis.fetch = (async (url: string | URL | Request) => {
+      const urlStr = typeof url === 'string' ? url : url instanceof URL ? url.toString() : url.url;
+      if (urlStr.includes('IncomingPhoneNumbers.json') && urlStr.includes('PhoneNumber=%2B18001234567')) {
+        return new Response(JSON.stringify({
+          incoming_phone_numbers: [{ sid: 'PN123abc', phone_number: '+18001234567' }],
+        }), { status: 200 });
+      }
+      if (urlStr.includes('Tollfree/Verifications')) {
+        verificationLookupUrl = urlStr;
+        return new Response(JSON.stringify({
+          verifications: [{ sid: 'TF_VER_001', status: 'TWILIO_APPROVED' }],
+        }), { status: 200 });
+      }
+      return originalFetch(url);
+    }) as typeof fetch;
+
+    const msg: TwilioConfigRequest = {
+      type: 'twilio_config',
+      action: 'sms_doctor',
+    };
+
+    const { ctx, sent } = createTestContext();
+    await handleTwilioConfig(msg, {} as net.Socket, ctx);
+
+    expect(sent).toHaveLength(1);
+    const res = sent[0] as {
+      success: boolean;
+      diagnostics?: { compliance?: { status?: string } };
+    };
+    expect(res.success).toBe(true);
+    expect(verificationLookupUrl).toContain('TollfreePhoneNumberSid=PN123abc');
+    expect(res.diagnostics?.compliance?.status).toBe('TWILIO_APPROVED');
+  });
 });

package/src/__tests__/intent-routing.test.ts

@@ -41,6 +41,8 @@ mock.module('../util/logger.js', () => ({
     new Proxy({} as Record<string, unknown>, {
       get: () => () => {},
     }),
+  isDebug: () => false,
+  truncateForLog: (v: string) => v,
 }));
 
 mock.module('../config/loader.js', () => ({