@vellumai/assistant 0.3.4 → 0.3.6

package/src/calls/call-conversation-messages.ts

@@ -0,0 +1,33 @@
+/**
+ * Persistence + formatting helpers for messages that belong in the
+ * dedicated voice conversation thread.
+ */
+
+import * as conversationStore from '../memory/conversation-store.js';
+import { getCallEvents, getCallSession } from './call-store.js';
+
+export function buildCallCompletionMessage(callSessionId: string): string {
+  const callSession = getCallSession(callSessionId);
+  const events = getCallEvents(callSessionId);
+  const duration = callSession?.endedAt && callSession?.startedAt
+    ? Math.round((callSession.endedAt - callSession.startedAt) / 1000)
+    : null;
+  const durationStr = duration != null ? ` (${duration}s)` : '';
+  const statusLabel = callSession?.status === 'failed'
+    ? 'Call failed'
+    : callSession?.status === 'cancelled'
+      ? 'Call cancelled'
+      : 'Call completed';
+  return `**${statusLabel}**${durationStr}. ${events.length} event(s) recorded.`;
+}
+
+export function persistCallCompletionMessage(conversationId: string, callSessionId: string): string {
+  const summaryText = buildCallCompletionMessage(callSessionId);
+  conversationStore.addMessage(
+    conversationId,
+    'assistant',
+    JSON.stringify([{ type: 'text', text: summaryText }]),
+    { userMessageChannel: 'voice', assistantMessageChannel: 'voice' },
+  );
+  return summaryText;
+}

package/src/calls/call-domain.ts

@@ -6,16 +6,19 @@
  */
 
 import { getLogger } from '../util/logger.js';
+import { getTwilioUserPhoneNumber } from '../config/env.js';
 import { isDeniedNumber } from './call-constants.js';
 import {
   createCallSession,
   getCallSession,
+  getCallSessionByCallSid,
   getActiveCallSessionForConversation,
   updateCallSession,
   getPendingQuestion,
   answerPendingQuestion,
   expirePendingQuestions,
 } from './call-store.js';
+import { isTerminalState } from './call-state-machine.js';
 import { getCallOrchestrator, unregisterCallOrchestrator } from './call-state.js';
 import { activeRelayConnections } from './relay-server.js';
 import { TwilioConversationRelayProvider } from './twilio-provider.js';
@@ -26,6 +29,9 @@ import { getSecureKey } from '../security/secure-keys.js';
 import type { CallSession } from './types.js';
 import { VALID_CALLER_IDENTITY_MODES } from '../config/schema.js';
 import type { AssistantConfig } from '../config/types.js';
+import { getOrCreateConversation } from '../memory/conversation-key-store.js';
+import { upsertBinding } from '../memory/external-conversation-store.js';
+import { addPointerMessage } from './call-pointer-messages.js';
 
 const log = getLogger('call-domain');
 
@@ -51,6 +57,7 @@ export type StartCallInput = {
   task: string;
   context?: string;
   conversationId: string;
+  assistantId?: string;
   callerIdentityMode?: 'assistant_number' | 'user_number';
 };
 
@@ -87,7 +94,8 @@ export type CallerIdentityResult =
  * - If `requestedMode` is provided but overrides are disabled, return an error.
  * - Otherwise, always use `assistant_number` (implicit default).
  *
- * For `assistant_number`: uses the Twilio phone number from `getTwilioConfig()`.
+ * For `assistant_number`: uses the Twilio phone number from
+ *   `getTwilioConfig(assistantId)` so multi-assistant mappings are honored.
  *   No eligibility check is performed — this is a fast path.
  * For `user_number`: uses `config.calls.callerIdentity.userNumber` or the
  *   secure key `credential:twilio:user_phone_number`, then validates that the
@@ -96,6 +104,7 @@ export type CallerIdentityResult =
 export async function resolveCallerIdentity(
   config: AssistantConfig,
   requestedMode?: 'assistant_number' | 'user_number',
+  assistantId?: string,
 ): Promise<CallerIdentityResult> {
   const identityConfig = config.calls.callerIdentity;
   let mode: 'assistant_number' | 'user_number';
@@ -118,8 +127,8 @@ export async function resolveCallerIdentity(
   }
 
   if (mode === 'assistant_number') {
-    const twilioConfig = getTwilioConfig();
-    log.info({ mode, source, fromNumber: twilioConfig.phoneNumber }, 'Resolved caller identity');
+    const twilioConfig = getTwilioConfig(assistantId);
+    log.info({ mode, source, fromNumber: twilioConfig.phoneNumber, assistantId }, 'Resolved caller identity');
     return { ok: true, mode, fromNumber: twilioConfig.phoneNumber, source };
   }
 
@@ -130,8 +139,8 @@ export async function resolveCallerIdentity(
   if (identityConfig.userNumber) {
     userNumber = identityConfig.userNumber;
     numberSource = 'user_config';
-  } else if (process.env.TWILIO_USER_PHONE_NUMBER) {
-    userNumber = process.env.TWILIO_USER_PHONE_NUMBER;
+  } else if (getTwilioUserPhoneNumber()) {
+    userNumber = getTwilioUserPhoneNumber()!;
     numberSource = 'env_var';
   } else {
     const secureKeyValue = getSecureKey('credential:twilio:user_phone_number');
@@ -169,13 +178,79 @@ export async function resolveCallerIdentity(
   return { ok: true, mode, fromNumber: userNumber, source: numberSource };
 }
 
+// ── Inbound voice session bootstrap ──────────────────────────────────
+
+export type CreateInboundVoiceSessionInput = {
+  callSid: string;
+  fromNumber: string;
+  toNumber: string;
+  assistantId?: string;
+};
+
+export type CreateInboundVoiceSessionResult = {
+  session: CallSession;
+  created: boolean;
+};
+
+/**
+ * Create (or reuse) a voice call session for an inbound call identified
+ * by its Twilio CallSid.
+ *
+ * Idempotent: if a session already exists for the given CallSid, it is
+ * returned without creating a duplicate. This handles Twilio webhook
+ * replays gracefully.
+ */
+export function createInboundVoiceSession(
+  input: CreateInboundVoiceSessionInput,
+): CreateInboundVoiceSessionResult {
+  const { callSid, fromNumber, toNumber, assistantId = 'self' } = input;
+
+  // Check if a session already exists for this CallSid (replay protection)
+  const existing = getCallSessionByCallSid(callSid);
+  if (existing) {
+    log.info({ callSid, callSessionId: existing.id }, 'Reusing existing session for inbound CallSid');
+    return { session: existing, created: false };
+  }
+
+  // Create a dedicated voice conversation keyed by CallSid so inbound calls
+  // get their own conversation thread.
+  const voiceConvKey = assistantId && assistantId !== 'self'
+    ? `asst:${assistantId}:voice:inbound:${callSid}`
+    : `voice:inbound:${callSid}`;
+  const { conversationId: voiceConversationId } = getOrCreateConversation(voiceConvKey);
+
+  upsertBinding({
+    conversationId: voiceConversationId,
+    sourceChannel: 'voice',
+    externalChatId: callSid,
+  });
+
+  const session = createCallSession({
+    conversationId: voiceConversationId,
+    provider: 'twilio',
+    fromNumber,
+    toNumber,
+    assistantId,
+  });
+
+  updateCallSession(session.id, { providerCallSid: callSid });
+  session.providerCallSid = callSid;
+
+  log.info(
+    { callSessionId: session.id, callSid, voiceConversationId, from: fromNumber, to: toNumber, assistantId },
+    'Created new inbound voice session',
+  );
+
+  return { session, created: true };
+}
+
 // ── Domain operations ────────────────────────────────────────────────
 
 /**
  * Initiate a new outbound call.
  */
 export async function startCall(input: StartCallInput): Promise<StartCallResult | CallError> {
-  const { phoneNumber, task, context: callContext, conversationId, callerIdentityMode } = input;
+  const { phoneNumber, task, context: callContext, conversationId, callerIdentityMode, assistantId = 'self' } = input;
 
   if (!phoneNumber || typeof phoneNumber !== 'string') {
     return { ok: false, error: 'phone_number is required and must be a string', status: 400 };
@@ -204,7 +279,7 @@ export async function startCall(input: StartCallInput): Promise<StartCallResult
     const provider = new TwilioConversationRelayProvider();
 
     // Resolve which phone number to use as caller ID
-    const identityResult = await resolveCallerIdentity(ingressConfig, callerIdentityMode);
+    const identityResult = await resolveCallerIdentity(ingressConfig, callerIdentityMode, assistantId);
     if (!identityResult.ok) {
       return { ok: false, error: identityResult.error, status: 400 };
     }
@@ -218,10 +293,33 @@ export async function startCall(input: StartCallInput): Promise<StartCallResult
       task: callContext ? `${task}\n\nContext: ${callContext}` : task,
       callerIdentityMode: identityResult.mode,
       callerIdentitySource: identityResult.source,
+      assistantId,
+      initiatedFromConversationId: conversationId,
     });
     sessionId = session.id;
 
-    log.info({ callSessionId: session.id, to: phoneNumber, from: fromNumber, task }, 'Initiating outbound call');
+    // Create a dedicated voice conversation for this call so that voice
+    // transcripts live in their own thread, separate from the chat that
+    // triggered the call.
+    const voiceConvKey = assistantId
+      ? `asst:${assistantId}:voice:call:${session.id}`
+      : `voice:call:${session.id}`;
+    const { conversationId: voiceConversationId } = getOrCreateConversation(voiceConvKey);
+
+    upsertBinding({
+      conversationId: voiceConversationId,
+      sourceChannel: 'voice',
+      externalChatId: session.id,
+    });
+
+    // Point the call session at the new voice conversation; the original
+    // chat is preserved in initiatedFromConversationId.
+    updateCallSession(session.id, {
+      conversationId: voiceConversationId,
+    });
+    session.conversationId = voiceConversationId;
+
+    log.info({ callSessionId: session.id, voiceConversationId, initiatedFrom: conversationId, to: phoneNumber, from: fromNumber, task }, 'Initiating outbound call');
 
     const { callSid } = await provider.initiateCall({
       from: fromNumber,
@@ -234,6 +332,9 @@ export async function startCall(input: StartCallInput): Promise<StartCallResult
 
     log.info({ callSessionId: session.id, callSid }, 'Call initiated successfully');
 
+    // Post a concise pointer message in the initiating conversation
+    addPointerMessage(conversationId, 'started', phoneNumber);
+
     return {
       ok: true,
       session: { ...session, providerCallSid: callSid },
@@ -257,6 +358,9 @@ export async function startCall(input: StartCallInput): Promise<StartCallResult
       });
     }
 
+    // Post a failure pointer message in the initiating conversation
+    addPointerMessage(conversationId, 'failed', phoneNumber, { reason: msg });
+
     return { ok: false, error: `Error initiating call: ${msg}`, status: 500 };
   }
 }
@@ -308,7 +412,7 @@ export async function cancelCall(input: CancelCallInput): Promise<{ ok: true; se
     return { ok: false, error: `No call session found with ID ${callSessionId}`, status: 404 };
   }
 
-  if (session.status === 'completed' || session.status === 'failed' || session.status === 'cancelled') {
+  if (isTerminalState(session.status)) {
     return { ok: false, error: `Call session ${callSessionId} has already ended with status: ${session.status}`, status: 409 };
   }
 
@@ -413,7 +517,7 @@ export async function relayInstruction(input: RelayInstructionInput): Promise<{
     return { ok: false, error: `No call session found with ID ${callSessionId}`, status: 404 };
   }
 
-  if (session.status === 'completed' || session.status === 'failed' || session.status === 'cancelled') {
+  if (isTerminalState(session.status)) {
     return { ok: false, error: `Call session ${callSessionId} is not active (status: ${session.status})`, status: 409 };
   }