vellum 0.2.12 → 0.2.14

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

@@ -31,6 +31,18 @@ mock.module('../util/logger.js', () => ({
   }),
 }));
 
+const mockCallsConfig = {
+  enabled: true,
+  provider: 'twilio',
+  maxDurationSeconds: 3600,
+  userConsultTimeoutSeconds: 120,
+  disclosure: { enabled: false, text: '' },
+  safety: { denyCategories: [] },
+  callerIdentity: {
+    allowPerCallOverride: true,
+  },
+};
+
 mock.module('../config/loader.js', () => ({
   getConfig: () => ({
     model: 'test',
@@ -39,13 +51,19 @@ mock.module('../config/loader.js', () => ({
     memory: { enabled: false },
     rateLimit: { maxRequestsPerMinute: 0, maxTokensPerSession: 0 },
     secretDetection: { enabled: false },
-    calls: {
+    calls: mockCallsConfig,
+  }),
+  loadConfig: () => ({
+    model: 'test',
+    provider: 'test',
+    apiKeys: {},
+    memory: { enabled: false },
+    rateLimit: { maxRequestsPerMinute: 0, maxTokensPerSession: 0 },
+    secretDetection: { enabled: false },
+    calls: mockCallsConfig,
+    ingress: {
       enabled: true,
-      provider: 'twilio',
-      maxDurationSeconds: 3600,
-      userConsultTimeoutSeconds: 120,
-      disclosure: { enabled: false, text: '' },
-      safety: { denyCategories: [] },
+      publicBaseUrl: 'https://test.example.com',
     },
   }),
 }));
@@ -241,6 +259,88 @@ describe('runtime call routes — HTTP layer', () => {
     await stopServer();
   });
 
+  test('POST /v1/calls/start with callerIdentityMode user_number is accepted', async () => {
+    await startServer();
+    ensureConversation('conv-start-identity-1');
+
+    const res = await fetch(callsUrl('/start'), {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', ...AUTH_HEADERS },
+      body: JSON.stringify({
+        phoneNumber: '+15559998888',
+        task: 'Book a table for two',
+        conversationId: 'conv-start-identity-1',
+        callerIdentityMode: 'user_number',
+      }),
+    });
+
+    // user_number mode requires a configured user phone number;
+    // since we haven't set one, this should return a 400 explaining why
+    expect(res.status).toBe(400);
+    const body = await res.json() as { error: string };
+    expect(body.error).toContain('user_number');
+
+    await stopServer();
+  });
+
+  test('POST /v1/calls/start without callerIdentityMode defaults to assistant_number', async () => {
+    await startServer();
+    ensureConversation('conv-start-identity-2');
+
+    const res = await fetch(callsUrl('/start'), {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', ...AUTH_HEADERS },
+      body: JSON.stringify({
+        phoneNumber: '+15559998888',
+        task: 'Book a table for two',
+        conversationId: 'conv-start-identity-2',
+      }),
+    });
+
+    expect(res.status).toBe(201);
+
+    const body = await res.json() as {
+      callSessionId: string;
+      callSid: string;
+      status: string;
+      toNumber: string;
+      fromNumber: string;
+      callerIdentityMode: string;
+    };
+
+    expect(body.callSessionId).toBeDefined();
+    expect(body.callSid).toBe('CA_mock_sid_123');
+    expect(body.fromNumber).toBe('+15550001111');
+    expect(body.callerIdentityMode).toBe('assistant_number');
+
+    await stopServer();
+  });
+
+  test('POST /v1/calls/start returns 400 for invalid callerIdentityMode', async () => {
+    await startServer();
+    ensureConversation('conv-start-identity-bogus');
+
+    const res = await fetch(callsUrl('/start'), {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', ...AUTH_HEADERS },
+      body: JSON.stringify({
+        phoneNumber: '+15559998888',
+        task: 'Book a table for two',
+        conversationId: 'conv-start-identity-bogus',
+        callerIdentityMode: 'bogus',
+      }),
+    });
+
+    expect(res.status).toBe(400);
+    const body = await res.json() as { error: string };
+    expect(body.error).toContain('Invalid callerIdentityMode');
+    expect(body.error).toContain('bogus');
+    expect(body.error).toContain('assistant_number');
+    expect(body.error).toContain('user_number');
+
+    await stopServer();
+  });
+
   // ── GET /v1/calls/:id ───────────────────────────────────────────────
 
   test('GET /v1/calls/:id returns call status', async () => {
@@ -456,4 +556,144 @@ describe('runtime call routes — HTTP layer', () => {
 
     await stopServer();
   });
+
+  // ── POST /v1/calls/:id/instruction ────────────────────────────────
+
+  test('POST /v1/calls/:id/instruction returns 400 for malformed JSON', async () => {
+    await startServer();
+    ensureConversation('conv-instr-badjson');
+
+    const session = createCallSession({
+      conversationId: 'conv-instr-badjson',
+      provider: 'twilio',
+      fromNumber: '+15550001111',
+      toNumber: '+15559998888',
+    });
+
+    const res = await fetch(callsUrl(`/${session.id}/instruction`), {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', ...AUTH_HEADERS },
+      body: 'not-json{{',
+    });
+
+    expect(res.status).toBe(400);
+    const body = await res.json() as { error: string };
+    expect(body.error).toContain('Invalid JSON');
+
+    await stopServer();
+  });
+
+  test('POST /v1/calls/:id/instruction returns 400 when instruction is empty', async () => {
+    await startServer();
+    ensureConversation('conv-instr-empty');
+
+    const session = createCallSession({
+      conversationId: 'conv-instr-empty',
+      provider: 'twilio',
+      fromNumber: '+15550001111',
+      toNumber: '+15559998888',
+    });
+
+    const res = await fetch(callsUrl(`/${session.id}/instruction`), {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', ...AUTH_HEADERS },
+      body: JSON.stringify({ instruction: '' }),
+    });
+
+    expect(res.status).toBe(400);
+    const body = await res.json() as { error: string };
+    expect(body.error).toContain('instructionText');
+
+    await stopServer();
+  });
+
+  test('POST /v1/calls/:id/instruction returns 400 when instruction field is missing', async () => {
+    await startServer();
+    ensureConversation('conv-instr-missing');
+
+    const session = createCallSession({
+      conversationId: 'conv-instr-missing',
+      provider: 'twilio',
+      fromNumber: '+15550001111',
+      toNumber: '+15559998888',
+    });
+
+    const res = await fetch(callsUrl(`/${session.id}/instruction`), {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', ...AUTH_HEADERS },
+      body: JSON.stringify({}),
+    });
+
+    expect(res.status).toBe(400);
+    const body = await res.json() as { error: string };
+    expect(body.error).toContain('instructionText');
+
+    await stopServer();
+  });
+
+  test('POST /v1/calls/:id/instruction returns 404 for unknown session', async () => {
+    await startServer();
+
+    const res = await fetch(callsUrl('/nonexistent-id/instruction'), {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', ...AUTH_HEADERS },
+      body: JSON.stringify({ instruction: 'Speed things up' }),
+    });
+
+    expect(res.status).toBe(404);
+    const body = await res.json() as { error: string };
+    expect(body.error).toContain('No call session found');
+
+    await stopServer();
+  });
+
+  test('POST /v1/calls/:id/instruction returns 409 for ended call', async () => {
+    await startServer();
+    ensureConversation('conv-instr-ended');
+
+    const session = createCallSession({
+      conversationId: 'conv-instr-ended',
+      provider: 'twilio',
+      fromNumber: '+15550001111',
+      toNumber: '+15559998888',
+    });
+
+    updateCallSession(session.id, { status: 'completed', endedAt: Date.now() });
+
+    const res = await fetch(callsUrl(`/${session.id}/instruction`), {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', ...AUTH_HEADERS },
+      body: JSON.stringify({ instruction: 'Speed things up' }),
+    });
+
+    expect(res.status).toBe(409);
+    const body = await res.json() as { error: string };
+    expect(body.error).toContain('not active');
+
+    await stopServer();
+  });
+
+  test('POST /v1/calls/:id/instruction returns 409 when no orchestrator', async () => {
+    await startServer();
+    ensureConversation('conv-instr-no-orch');
+
+    const session = createCallSession({
+      conversationId: 'conv-instr-no-orch',
+      provider: 'twilio',
+      fromNumber: '+15550001111',
+      toNumber: '+15559998888',
+    });
+
+    const res = await fetch(callsUrl(`/${session.id}/instruction`), {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', ...AUTH_HEADERS },
+      body: JSON.stringify({ instruction: 'Speed things up' }),
+    });
+
+    expect(res.status).toBe(409);
+    const body = await res.json() as { error: string };
+    expect(body.error).toContain('orchestrator');
+
+    await stopServer();
+  });
 });