@vellumai/assistant 0.6.6 → 0.7.1

package/src/calls/call-domain.ts

@@ -66,20 +66,20 @@ function postFailedCallPointer(
 
 // ── Result types ─────────────────────────────────────────────────────
 
-export interface StartCallResult {
+interface StartCallResult {
   ok: true;
   session: CallSession;
   callSid: string;
   callerIdentityMode: "assistant_number" | "user_number";
 }
 
-export interface CallError {
+interface CallError {
   ok: false;
   error: string;
   status?: number;
 }
 
-export type StartCallInput = {
+type StartCallInput = {
   phoneNumber: string;
   task: string;
   context?: string;
@@ -89,32 +89,32 @@ export type StartCallInput = {
   skipDisclosure?: boolean;
 };
 
-export type CancelCallInput = {
+type CancelCallInput = {
   callSessionId: string;
   reason?: string;
 };
 
-export type AnswerCallInput = {
+type AnswerCallInput = {
   callSessionId: string;
   answer: string;
   /** When provided, the answer is matched to this specific pending question/consultation. */
   pendingQuestionId?: string;
 };
 
-export type RelayInstructionInput = {
+type RelayInstructionInput = {
   callSessionId: string;
   instructionText: string;
 };
 
 // ── Caller identity resolution ───────────────────────────────────────
 
-export type CallerIdentitySource =
+type CallerIdentitySource =
   | "per_call_override"
   | "implicit_default"
   | "user_config"
   | "secure_key";
 
-export type CallerIdentityResult =
+type CallerIdentityResult =
   | {
       ok: true;
       mode: "assistant_number" | "user_number";
@@ -247,14 +247,14 @@ export async function resolveCallerIdentity(
 
 // ── Inbound voice session bootstrap ──────────────────────────────────
 
-export type CreateInboundVoiceSessionInput = {
+type CreateInboundVoiceSessionInput = {
   callSid: string;
   fromNumber: string;
   toNumber: string;
   assistantId?: string;
 };
 
-export type CreateInboundVoiceSessionResult = {
+type CreateInboundVoiceSessionResult = {
   session: CallSession;
   created: boolean;
 };
@@ -897,7 +897,7 @@ export async function relayInstruction(
 
 // ── Verification call ─────────────────────────────────────────────────
 
-export type StartVerificationCallInput = {
+type StartVerificationCallInput = {
   phoneNumber: string;
   verificationSessionId: string;
   assistantId?: string;
@@ -905,7 +905,7 @@ export type StartVerificationCallInput = {
   originConversationId?: string;
 };
 
-export type StartVerificationCallResult =
+type StartVerificationCallResult =
   | { ok: true; callSessionId: string; callSid: string }
   | CallError;
 
@@ -1032,14 +1032,14 @@ export async function startVerificationCall(
 
 // ── Invite call ───────────────────────────────────────────────────────
 
-export type StartInviteCallInput = {
+type StartInviteCallInput = {
   phoneNumber: string;
   friendName: string;
   guardianName: string;
   assistantId?: string;
 };
 
-export type StartInviteCallResult = { ok: true; callSid: string } | CallError;
+type StartInviteCallResult = { ok: true; callSid: string } | CallError;
 
 /**
  * Initiate an outbound call to deliver a voice invite to a contact.

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

@@ -13,7 +13,6 @@ import {
   addMessage,
   getConversationOriginChannel,
   getConversationRecentProvenanceTrustClass,
-  getConversationType,
 } from "../memory/conversation-crud.js";
 import { getLogger } from "../util/logger.js";
 import {
@@ -24,14 +23,14 @@ import {
 
 const log = getLogger("call-pointer-messages");
 
-export type PointerEvent =
+type PointerEvent =
   | "started"
   | "completed"
   | "failed"
   | "verification_succeeded"
   | "verification_failed";
 
-export type PointerAudienceMode = "auto" | "trusted" | "untrusted";
+type PointerAudienceMode = "auto" | "trusted" | "untrusted";
 
 /**
  * Daemon-injected function that sends a message through the daemon conversation
@@ -43,7 +42,7 @@ export type PointerAudienceMode = "auto" | "trusted" | "untrusted";
  *   should validate the output and throw if any are missing so the
  *   deterministic fallback fires.
  */
-export type PointerMessageProcessor = (
+type PointerMessageProcessor = (
   conversationId: string,
   instruction: string,
   requiredFacts?: string[],
@@ -80,7 +79,6 @@ export function resetPointerMessageProcessor(): void {
  *
  * Trusted when:
  * - recent message provenance trust class is 'guardian' or 'trusted_contact'
- * - conversation conversationType is 'private' (local desktop-origin context)
  * - conversation origin channel is 'vellum' (desktop app)
  *
  * Untrusted by default when insufficient evidence.
@@ -89,15 +87,12 @@ function resolvePointerAudienceTrust(conversationId: string): boolean {
   try {
     // Check provenance trust class on recent messages first — this catches
     // trusted contacts who initiate calls from gateway channels (e.g. WhatsApp)
-    // where the conversation itself isn't a desktop-origin private conversation.
+    // where the conversation itself isn't desktop-origin.
     const provenance =
       getConversationRecentProvenanceTrustClass(conversationId);
     if (provenance === "guardian" || provenance === "trusted_contact")
       return true;
 
-    const conversationType = getConversationType(conversationId);
-    if (conversationType === "private") return true;
-
     const originChannel = getConversationOriginChannel(conversationId);
     if (originChannel === "vellum") return true;
   } catch {

package/src/calls/call-store.ts

@@ -1,7 +1,8 @@
 import { and, desc, eq, notInArray, or } from "drizzle-orm";
 import { v4 as uuid } from "uuid";
 
-import { getDb, rawChanges, rawGet, rawRun } from "../memory/db.js";
+import { getDb } from "../memory/db-connection.js";
+import { rawChanges, rawRun } from "../memory/raw-query.js";
 import {
   callEvents,
   callPendingQuestions,
@@ -378,39 +379,6 @@ export function buildCallbackDedupeKey(
   return `${callSid}:${callStatus}:${discriminator}`;
 }
 
-/**
- * Check whether a callback dedupe key has already been processed (read-only).
- * Returns true if the key already exists, false otherwise.
- */
-export function isCallbackProcessed(dedupeKey: string): boolean {
-  return (
-    rawGet<{ 1: number }>(
-      `SELECT 1 FROM processed_callbacks WHERE dedupe_key = ?`,
-      dedupeKey,
-    ) != null
-  );
-}
-
-/**
- * Record a callback as processed. Should be called AFTER downstream writes
- * (session updates, event recording) have succeeded so that Twilio retries
- * are not silently dropped if those writes fail.
- *
- * Uses INSERT OR IGNORE so concurrent calls for the same key are safe.
- */
-export function recordProcessedCallback(
-  dedupeKey: string,
-  callSessionId: string,
-): void {
-  rawRun(
-    `INSERT OR IGNORE INTO processed_callbacks (id, dedupe_key, call_session_id, created_at) VALUES (?, ?, ?, ?)`,
-    uuid(),
-    dedupeKey,
-    callSessionId,
-    Date.now(),
-  );
-}
-
 /**
  * Atomically claim a callback for processing. Returns a unique claim ID
  * (string) if this caller won the claim, or null if another caller already

package/src/calls/guardian-action-sweep.ts

@@ -49,8 +49,6 @@ export interface ExpiryDeliveryInfo {
 export async function sendGuardianExpiryNotices(
   deliveries: ExpiryDeliveryInfo[],
   assistantId: string,
-  gatewayBaseUrl: string,
-  mintBearerToken?: () => string,
   guardianActionCopyGenerator?: GuardianActionCopyGenerator,
 ): Promise<void> {
   for (const delivery of deliveries) {
@@ -79,21 +77,17 @@ export async function sendGuardianExpiryNotices(
             userMessageChannel: "phone",
             assistantMessageChannel: "vellum",
             userMessageInterface: "phone",
-            assistantMessageInterface: "vellum",
+            assistantMessageInterface: "web",
           },
         );
       } else if (delivery.destinationChatId) {
-        // External channel — send expiry notice
-        const deliverUrl = `${gatewayBaseUrl}/deliver/${delivery.destinationChannel}`;
-        await deliverChannelReply(
-          deliverUrl,
-          {
-            chatId: delivery.destinationChatId,
-            text: expiryText,
-            assistantId,
-          },
-          mintBearerToken?.(),
-        );
+        // External channel — send expiry notice via direct delivery
+        const deliverUrl = `/deliver/${delivery.destinationChannel}`;
+        await deliverChannelReply(deliverUrl, {
+          chatId: delivery.destinationChatId,
+          text: expiryText,
+          assistantId,
+        });
       }
     } catch (err) {
       log.error(
@@ -108,8 +102,6 @@ export async function sendGuardianExpiryNotices(
  * Sweep expired guardian action requests and clean up.
  */
 export async function sweepExpiredGuardianActions(
-  gatewayBaseUrl: string,
-  mintBearerToken?: () => string,
   guardianActionCopyGenerator?: GuardianActionCopyGenerator,
 ): Promise<void> {
   const expired = getExpiredGuardianActionRequests();
@@ -132,16 +124,12 @@ export async function sweepExpiredGuardianActions(
     await sendGuardianExpiryNotices(
       deliveries,
       DAEMON_INTERNAL_ASSISTANT_ID,
-      gatewayBaseUrl,
-      mintBearerToken,
       guardianActionCopyGenerator,
     );
   }
 }
 
 export function startGuardianActionSweep(
-  gatewayBaseUrl: string,
-  mintBearerToken?: () => string,
   guardianActionCopyGenerator?: GuardianActionCopyGenerator,
 ): void {
   if (sweepTimer) return;
@@ -149,11 +137,7 @@ export function startGuardianActionSweep(
     if (sweepInProgress) return;
     sweepInProgress = true;
     try {
-      await sweepExpiredGuardianActions(
-        gatewayBaseUrl,
-        mintBearerToken,
-        guardianActionCopyGenerator,
-      );
+      await sweepExpiredGuardianActions(guardianActionCopyGenerator);
     } catch (err) {
       log.error({ err }, "Guardian action sweep failed");
     } finally {

package/src/calls/guardian-dispatch.ts

@@ -17,7 +17,6 @@ import {
 } from "../memory/canonical-guardian-store.js";
 import { emitNotificationSignal } from "../notifications/emit-signal.js";
 import type { NotificationDeliveryResult } from "../notifications/types.js";
-import { ensureVellumGuardianBinding } from "../runtime/guardian-vellum-migration.js";
 import { getLogger } from "../util/logger.js";
 import { getUserConsultationTimeoutMs } from "./call-constants.js";
 import type { CallPendingQuestion } from "./types.js";
@@ -106,28 +105,10 @@ async function dispatchGuardianQuestionInner(
       guardianPrincipalId = guardianResult.contact.principalId;
     }
 
-    // Self-heal: if contacts don't have a principalId, bootstrap via
-    // ensureVellumGuardianBinding so the pending_question request can
-    // be attributed.
-    if (!guardianPrincipalId) {
-      log.info(
-        { callSessionId, assistantId },
-        "No guardian principal from contacts — self-healing for voice dispatch",
-      );
-      try {
-        guardianPrincipalId = ensureVellumGuardianBinding(assistantId);
-      } catch (err) {
-        log.warn(
-          { err, callSessionId, assistantId },
-          "ensureVellumGuardianBinding failed during voice dispatch self-heal",
-        );
-      }
-    }
-
     if (!guardianPrincipalId) {
       log.error(
         { callSessionId, assistantId },
-        "Voice guardian dispatch: no guardianPrincipalId after contacts + self-heal — cannot create pending_question",
+        "Voice guardian dispatch: no guardianPrincipalId — gateway may not have started yet; cannot create pending_question",
       );
       return;
     }

package/src/calls/guardian-question-copy.ts

@@ -6,18 +6,7 @@
  * when the provider is unavailable or generation fails/times out.
  */
 
-import {
-  createTimeout,
-  extractText,
-  resolveConfiguredProvider,
-  userMessage,
-} from "../providers/provider-send-message.js";
-import { getLogger } from "../util/logger.js";
-
-const log = getLogger("guardian-question-copy");
-
 /** Timeout for the generative copy call (ms). */
-const GENERATION_TIMEOUT_MS = 5_000;
 
 export interface GuardianCopy {
   conversationTitle: string;
@@ -39,100 +28,3 @@ export function buildFallbackCopy(questionText: string): GuardianCopy {
     ].join("\n"),
   };
 }
-
-/**
- * Generate guardian conversation copy (title + initial message) via the configured
- * LLM provider. Returns deterministic fallback when the provider is unavailable,
- * generation times out, or any error occurs.
- */
-export async function generateGuardianCopy(
-  questionText: string,
-  requestCode?: string,
-): Promise<GuardianCopy> {
-  const fallback = buildFallbackCopy(questionText);
-
-  // If no provider is configured, return fallback immediately
-  const resolved = await resolveConfiguredProvider("guardianQuestionCopy");
-  if (!resolved) {
-    log.debug(
-      "No provider available for guardian copy generation, using fallback",
-    );
-    return fallback;
-  }
-
-  const { signal, cleanup } = createTimeout(GENERATION_TIMEOUT_MS);
-
-  try {
-    const prompt = [
-      "Generate a conversation title and initial message for a guardian question during a live phone call.",
-      "",
-      `Question: ${questionText}`,
-      ...(requestCode ? [`Reference code: ${requestCode}`] : []),
-      "",
-      "Requirements:",
-      '- TITLE: An emoji-prefixed, attention-oriented, concise title (under 80 characters). Do NOT start with "Guardian question:". Use a relevant warning or alert emoji.',
-      "- MESSAGE: A clear initial message that includes the question text, mentions this is a live phone call waiting for the user's input, and asks them to reply with their answer.",
-      "",
-      "Respond in exactly this format (no extra text):",
-      "TITLE: <your title>",
-      "MESSAGE: <your message>",
-    ].join("\n");
-
-    const response = await resolved.provider.sendMessage(
-      [userMessage(prompt)],
-      undefined,
-      undefined,
-      { signal, config: { callSite: "guardianQuestionCopy" } },
-    );
-
-    const text = extractText(response);
-    const parsed = parseGeneratedCopy(text);
-
-    if (parsed) {
-      return parsed;
-    }
-
-    log.warn(
-      { raw: text },
-      "Failed to parse generated guardian copy, using fallback",
-    );
-    return fallback;
-  } catch (err) {
-    if (signal.aborted) {
-      log.warn("Guardian copy generation timed out, using fallback");
-    } else {
-      log.warn({ err }, "Guardian copy generation failed, using fallback");
-    }
-    return fallback;
-  } finally {
-    cleanup();
-  }
-}
-
-/**
- * Parse the structured TITLE/MESSAGE response from the model.
- * Returns null if the format is not matched.
- */
-function parseGeneratedCopy(text: string): GuardianCopy | null {
-  const titleMatch = text.match(/^TITLE:\s*(.+)/m);
-  const messageMatch = text.match(/^MESSAGE:\s*([\s\S]+)/m);
-
-  if (!titleMatch || !messageMatch) {
-    return null;
-  }
-
-  const title = titleMatch[1].trim();
-  const message = messageMatch[1].trim();
-
-  // Sanity checks: title must be non-empty and under 80 chars, message must be non-empty
-  if (!title || title.length > 80 || !message) {
-    return null;
-  }
-
-  // Reject the old static prefix — the model is guided towards better titles but has final say
-  if (/^guardian question:/i.test(title)) {
-    return null;
-  }
-
-  return { conversationTitle: title, initialMessage: message };
-}

package/src/calls/media-stream-audio-transcode.ts

@@ -24,7 +24,7 @@
  * 8000 samples/sec * 0.020 sec = 160 samples per frame.
  * Each mu-law sample is 1 byte, so each frame is 160 bytes.
  */
-export const MULAW_FRAME_SIZE = 160;
+const MULAW_FRAME_SIZE = 160;
 
 /**
  * Bias constant used in the linear-to-mu-law compression formula
@@ -52,7 +52,7 @@ const MULAW_SEG_TABLE = [0, 0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3];
  * signed 16-bit integer (range: -32768 to +32767). The output is an
  * unsigned 8-bit mu-law value.
  */
-export function linearToMulaw(sample: number): number {
+function linearToMulaw(sample: number): number {
   // Determine sign and clamp magnitude
   const sign = (sample >> 8) & 0x80;
   if (sign !== 0) sample = -sample;
@@ -132,42 +132,3 @@ export function chunkMulawToBase64Frames(mulawBuffer: Buffer): string[] {
 // ---------------------------------------------------------------------------
 // High-level: raw audio bytes to sendable base64 frames
 // ---------------------------------------------------------------------------
-
-/**
- * Accepted audio formats for transcoding into mu-law frames.
- *
- * Currently only `mulaw` (already in the target format) and `pcm16` (16-bit
- * signed LE PCM at 8 kHz) are supported. Higher-level formats (mp3, wav,
- * opus) require decoding to PCM first -- callers should handle that
- * conversion before invoking this helper.
- */
-export type TranscodeInputFormat = "mulaw" | "pcm16";
-
-/**
- * Transcode raw audio bytes into Twilio-compatible base64-encoded mu-law
- * frames.
- *
- * @param audio - Raw audio bytes in the specified format.
- * @param format - The format of the input audio.
- * @returns Array of base64-encoded mu-law frames ready for
- *   `MediaStreamOutput.sendAudioPayload()`.
- */
-export function transcodeToMulawFrames(
-  audio: Uint8Array,
-  format: TranscodeInputFormat,
-): string[] {
-  let mulawBuffer: Buffer;
-
-  switch (format) {
-    case "mulaw":
-      mulawBuffer = Buffer.from(audio);
-      break;
-    case "pcm16":
-      mulawBuffer = pcm16ToMulaw(audio);
-      break;
-    default:
-      throw new Error(`Unsupported transcode format: ${format as string}`);
-  }
-
-  return chunkMulawToBase64Frames(mulawBuffer);
-}

package/src/calls/media-stream-server.ts

@@ -53,6 +53,7 @@ import {
 import { finalizeCall } from "./finalize-call.js";
 import { MediaStreamOutput } from "./media-stream-output.js";
 import { parseMediaStreamFrame } from "./media-stream-parser.js";
+import type { MediaStreamStartEvent } from "./media-stream-protocol.js";
 import {
   MediaStreamSttSession,
   type MediaStreamSttSessionCallbacks,
@@ -295,9 +296,7 @@ export class MediaStreamCallSession {
 
   // ── Internal: media-stream event handlers ─────────────────────────
 
-  private handleStart(
-    event: import("./media-stream-protocol.js").MediaStreamStartEvent,
-  ): void {
+  private handleStart(event: MediaStreamStartEvent): void {
     this.streamSid = event.streamSid;
     this.callSid = event.start.callSid;
 

package/src/calls/media-stream-stt-session.ts

@@ -350,12 +350,10 @@ export class MediaStreamSttSession {
  * threshold. The threshold is tuned for Twilio's 8 kHz, 8-bit mu-law
  * stream where typical silence RMS is ~50-100 and speech is >300.
  *
- * Exported for testing.
- *
  * @param base64Payload - Base64-encoded mu-law audio chunk from Twilio.
  * @returns `true` if the chunk likely contains speech, `false` otherwise.
  */
-export function detectSpeechActivity(base64Payload: string): boolean {
+function detectSpeechActivity(base64Payload: string): boolean {
   const SPEECH_ENERGY_THRESHOLD = 200;
 
   let raw: Buffer;

package/src/calls/relay-access-wait.ts

@@ -22,7 +22,7 @@ const log = getLogger("relay-access-wait");
 
 // ── Wait-utterance classification ────────────────────────────────────
 
-export type WaitUtteranceClass =
+type WaitUtteranceClass =
   | "empty"
   | "patience_check"
   | "impatient"
@@ -108,10 +108,7 @@ export function classifyWaitUtterance(
  * Generate a non-repetitive heartbeat message for the caller based
  * on the current sequence counter and guardian label.
  */
-export function getHeartbeatMessage(
-  sequence: number,
-  guardianLabel: string,
-): string {
+function getHeartbeatMessage(sequence: number, guardianLabel: string): string {
   const messages = [
     `Still waiting to hear back from ${guardianLabel}. Thank you for your patience.`,
     `I'm still trying to reach ${guardianLabel}. One moment please.`,
@@ -124,7 +121,7 @@ export function getHeartbeatMessage(
 
 // ── Heartbeat scheduling ─────────────────────────────────────────────
 
-export interface ScheduleNextHeartbeatParams {
+interface ScheduleNextHeartbeatParams {
   isWaitActive: () => boolean;
   accessRequestWaitStartedAt: number;
   callSessionId: string;
@@ -194,7 +191,7 @@ export function scheduleNextHeartbeat(
 
 // ── Callback handoff notification ────────────────────────────────────
 
-export interface EmitAccessRequestCallbackHandoffParams {
+interface EmitAccessRequestCallbackHandoffParams {
   reason: "timeout" | "transport_closed";
   callbackOptIn: boolean;
   accessRequestId: string | null;
@@ -205,7 +202,7 @@ export interface EmitAccessRequestCallbackHandoffParams {
   callSessionId: string;
 }
 
-export interface EmitAccessRequestCallbackHandoffResult {
+interface EmitAccessRequestCallbackHandoffResult {
   /** Whether the notification was actually emitted. */
   emitted: boolean;
   /** Updated callbackHandoffNotified flag for the caller to persist. */