@vellumai/assistant 0.4.41 → 0.4.43

package/src/runtime/channel-readiness-service.ts

@@ -1,11 +1,6 @@
-import {
-  getPhoneNumberSid,
-  getTollFreeVerificationStatus,
-  getTwilioCredentials,
-  hasTwilioCredentials,
-} from "../calls/twilio-rest.js";
+import { resolveTwilioPhoneNumber } from "../calls/twilio-config.js";
+import { hasTwilioCredentials } from "../calls/twilio-rest.js";
 import { getChannelInvitePolicy } from "../channels/config.js";
-import { getTwilioPhoneNumberEnv } from "../config/env.js";
 import { loadRawConfig } from "../config/loader.js";
 import { getEmailService } from "../email/service.js";
 import { getSecureKey } from "../security/secure-keys.js";
@@ -17,37 +12,11 @@ import type {
   ChannelReadinessSnapshot,
   ReadinessCheckResult,
 } from "./channel-readiness-types.js";
+import { probeLocalGatewayHealth } from "./local-gateway-health.js";
 
 /** Remote check results are cached for 5 minutes before being considered stale. */
 export const REMOTE_TTL_MS = 5 * 60 * 1000;
 
-// ── SMS Probe ───────────────────────────────────────────────────────────────
-
-// Keep Twilio phone-number resolution inside an already-authorized module so
-// the secure-key import boundary does not expand for shared config helpers.
-function resolveSmsPhoneNumber(): string {
-  return resolveTwilioPhoneNumber();
-}
-
-function resolveTwilioPhoneNumber(): string {
-  try {
-    const raw = loadRawConfig();
-    const smsConfig = (raw?.sms ?? {}) as Record<string, unknown>;
-    return (
-      getTwilioPhoneNumberEnv() ||
-      (smsConfig.phoneNumber as string) ||
-      getSecureKey("credential:twilio:phone_number") ||
-      ""
-    );
-  } catch {
-    return (
-      getTwilioPhoneNumberEnv() ||
-      getSecureKey("credential:twilio:phone_number") ||
-      ""
-    );
-  }
-}
-
 function hasIngressConfigured(): boolean {
   try {
     const raw = loadRawConfig();
@@ -62,128 +31,11 @@ function hasIngressConfigured(): boolean {
   }
 }
 
-const smsProbe: ChannelProbe = {
-  channel: "sms",
-  runLocalChecks(): ReadinessCheckResult[] {
-    const results: ReadinessCheckResult[] = [];
-
-    const hasCreds = hasTwilioCredentials();
-    results.push({
-      name: "twilio_credentials",
-      passed: hasCreds,
-      message: hasCreds
-        ? "Twilio credentials are configured"
-        : "Twilio Account SID and Auth Token are not configured",
-    });
-
-    const resolvedNumber = resolveSmsPhoneNumber();
-    const hasPhone = !!resolvedNumber;
-    results.push({
-      name: "phone_number",
-      passed: hasPhone,
-      message: hasPhone
-        ? "Phone number is assigned"
-        : "No phone number assigned",
-    });
-
-    const hasIngress = hasIngressConfigured();
-    results.push({
-      name: "ingress",
-      passed: hasIngress,
-      message: hasIngress
-        ? "Public ingress URL is configured"
-        : "Public ingress URL is not configured or disabled",
-    });
-
-    return results;
-  },
-  async runRemoteChecks(): Promise<ReadinessCheckResult[]> {
-    if (!hasTwilioCredentials()) return [];
-
-    let accountSid: string;
-    let authToken: string;
-    try {
-      ({ accountSid, authToken } = getTwilioCredentials());
-    } catch {
-      return [];
-    }
-
-    const phoneNumber = resolveSmsPhoneNumber();
-    if (!phoneNumber) return [];
-
-    // Only toll-free numbers need verification checks
-    const tollFreePrefixes = [
-      "+1800",
-      "+1833",
-      "+1844",
-      "+1855",
-      "+1866",
-      "+1877",
-      "+1888",
-    ];
-    const isTollFree = tollFreePrefixes.some((prefix) =>
-      phoneNumber.startsWith(prefix),
-    );
-    if (!isTollFree) return [];
-
-    try {
-      const phoneSid = await getPhoneNumberSid(
-        accountSid,
-        authToken,
-        phoneNumber,
-      );
-      if (!phoneSid) {
-        return [
-          {
-            name: "toll_free_verification",
-            passed: false,
-            message: `Phone number ${phoneNumber} not found on Twilio account`,
-          },
-        ];
-      }
-
-      const verification = await getTollFreeVerificationStatus(
-        accountSid,
-        authToken,
-        phoneSid,
-      );
-      if (!verification) {
-        return [
-          {
-            name: "toll_free_verification",
-            passed: false,
-            message:
-              "No toll-free verification submitted. Verification is required for SMS sending.",
-          },
-        ];
-      }
-
-      const approved = verification.status === "TWILIO_APPROVED";
-      return [
-        {
-          name: "toll_free_verification",
-          passed: approved,
-          message: `toll_free_verification: ${verification.status}`,
-        },
-      ];
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      return [
-        {
-          name: "toll_free_verification",
-          passed: false,
-          message: `Failed to check toll-free verification: ${message}`,
-        },
-      ];
-    }
-  },
-};
-
 // ── Voice Probe ─────────────────────────────────────────────────────────────
 
 const voiceProbe: ChannelProbe = {
-  channel: "voice",
-  runLocalChecks(): ReadinessCheckResult[] {
+  channel: "phone",
+  async runLocalChecks(): Promise<ReadinessCheckResult[]> {
     const results: ReadinessCheckResult[] = [];
 
     const hasCreds = hasTwilioCredentials();
@@ -195,7 +47,7 @@ const voiceProbe: ChannelProbe = {
         : "Twilio Account SID and Auth Token are not configured",
     });
 
-    const resolvedNumber = resolveSmsPhoneNumber();
+    const resolvedNumber = resolveTwilioPhoneNumber();
     const hasPhone = !!resolvedNumber;
     results.push({
       name: "phone_number",
@@ -214,6 +66,19 @@ const voiceProbe: ChannelProbe = {
         : "Public ingress URL is not configured or disabled",
     });
 
+    if (hasIngress) {
+      const gatewayHealth = await probeLocalGatewayHealth();
+      results.push({
+        name: "gateway_health",
+        passed: gatewayHealth.healthy,
+        message: gatewayHealth.healthy
+          ? `Local gateway is serving requests at ${gatewayHealth.target}`
+          : `Local gateway is not serving requests at ${gatewayHealth.target}${
+              gatewayHealth.error ? `: ${gatewayHealth.error}` : ""
+            }`,
+      });
+    }
+
     return results;
   },
 };
@@ -446,8 +311,9 @@ export class ChannelReadinessService {
 
   /**
    * Get readiness snapshots for the specified channel (or all registered channels).
-   * Local checks always run inline. Remote checks run only when `includeRemote`
-   * is true and the cache is stale or missing.
+   * Local checks always run on demand, including async loopback probes. Remote
+   * checks run only when `includeRemote` is true and the cache is stale or
+   * missing.
    */
   async getReadiness(
     channel?: ChannelId,
@@ -464,7 +330,7 @@ export class ChannelReadinessService {
       }
 
       const probeContext: ChannelProbeContext = {};
-      const localChecks = probe.runLocalChecks(probeContext);
+      const localChecks = await probe.runLocalChecks(probeContext);
       let remoteChecks: ReadinessCheckResult[] | undefined;
       let remoteChecksFreshlyFetched = false;
       let remoteChecksAffectReadiness = false;
@@ -575,10 +441,9 @@ export class ChannelReadinessService {
 
 // ── Factory ─────────────────────────────────────────────────────────────────
 
-/** Create a service instance with built-in SMS, Voice, Telegram, Email, WhatsApp, and Slack probes registered. */
+/** Create a service instance with built-in Voice, Telegram, Email, WhatsApp, and Slack probes registered. */
 export function createReadinessService(): ChannelReadinessService {
   const service = new ChannelReadinessService();
-  service.registerProbe(smsProbe);
   service.registerProbe(voiceProbe);
   service.registerProbe(telegramProbe);
   service.registerProbe(emailProbe);

package/src/runtime/channel-readiness-types.ts

@@ -26,10 +26,14 @@ export interface ChannelReadinessSnapshot {
 // eslint-disable-next-line @typescript-eslint/no-empty-object-type
 export interface ChannelProbeContext {}
 
+export type Awaitable<T> = T | Promise<T>;
+
 /** Probe interface that channels implement to provide readiness checks. */
 export interface ChannelProbe {
   channel: ChannelId;
-  runLocalChecks(context?: ChannelProbeContext): ReadinessCheckResult[];
+  runLocalChecks(
+    context?: ChannelProbeContext,
+  ): Awaitable<ReadinessCheckResult[]>;
   runRemoteChecks?(
     context?: ChannelProbeContext,
   ): Promise<ReadinessCheckResult[]>;

package/src/runtime/channel-reply-delivery.ts

@@ -1,6 +1,6 @@
-import { renderHistoryContent } from "../daemon/handlers.js";
+import { renderHistoryContent } from "../daemon/handlers/shared.js";
 import * as attachmentsStore from "../memory/attachments-store.js";
-import * as conversationStore from "../memory/conversation-store.js";
+import { getMessages } from "../memory/conversation-crud.js";
 import type { ChannelDeliveryResult } from "./gateway-client.js";
 import { deliverChannelReply } from "./gateway-client.js";
 import type { RuntimeAttachmentMetadata } from "./http-types.js";
@@ -169,7 +169,7 @@ export async function deliverReplyViaCallback(
   assistantId?: string,
   options?: DeliverReplyOptions,
 ): Promise<void> {
-  const msgs = conversationStore.getMessages(conversationId);
+  const msgs = getMessages(conversationId);
   for (let i = msgs.length - 1; i >= 0; i--) {
     if (msgs[i].role !== "assistant") continue;
 
@@ -208,3 +208,43 @@ export async function deliverReplyViaCallback(
     break;
   }
 }
+
+/**
+ * Deliver only the attachments from the last assistant message, skipping text.
+ * Used when streaming already delivered the text content and only file
+ * attachments remain to be sent via the normal delivery path.
+ */
+export async function deliverAttachmentsOnly(
+  conversationId: string,
+  externalChatId: string,
+  callbackUrl: string,
+  bearerToken?: string,
+  assistantId?: string,
+): Promise<void> {
+  const msgs = getMessages(conversationId);
+  for (let i = msgs.length - 1; i >= 0; i--) {
+    if (msgs[i].role !== "assistant") continue;
+
+    const linked = attachmentsStore.getAttachmentMetadataForMessage(msgs[i].id);
+    if (linked.length === 0) return;
+
+    const replyAttachments: RuntimeAttachmentMetadata[] = linked.map((a) => ({
+      id: a.id,
+      filename: a.originalFilename,
+      mimeType: a.mimeType,
+      sizeBytes: a.sizeBytes,
+      kind: a.kind,
+    }));
+
+    await deliverChannelReply(
+      callbackUrl,
+      {
+        chatId: externalChatId,
+        attachments: replyAttachments,
+        assistantId,
+      },
+      bearerToken,
+    );
+    break;
+  }
+}

package/src/runtime/channel-retry-sweep.ts

@@ -8,7 +8,9 @@ import {
   parseInterfaceId,
 } from "../channels/types.js";
 import type { TrustContext } from "../daemon/session-runtime-assembly.js";
-import * as channelDeliveryStore from "../memory/channel-delivery-store.js";
+import * as deliveryChannels from "../memory/delivery-channels.js";
+import * as deliveryCrud from "../memory/delivery-crud.js";
+import * as deliveryStatus from "../memory/delivery-status.js";
 import { getLogger } from "../util/logger.js";
 import { deliverReplyViaCallback } from "./channel-reply-delivery.js";
 import type { MessageProcessor } from "./http-types.js";
@@ -33,10 +35,6 @@ function parseTrustRuntimeContext(value: unknown): TrustContext | undefined {
       : undefined;
   if (!rawSourceChannel || !isChannelId(rawSourceChannel)) return undefined;
   const sourceChannel = rawSourceChannel;
-  const denialReason =
-    raw.denialReason === "no_binding" || raw.denialReason === "no_identity"
-      ? raw.denialReason
-      : undefined;
   return {
     sourceChannel,
     trustClass,
@@ -72,7 +70,6 @@ function parseTrustRuntimeContext(value: unknown): TrustContext | undefined {
         : undefined,
     requesterChatId:
       typeof raw.requesterChatId === "string" ? raw.requesterChatId : undefined,
-    denialReason,
   };
 }
 
@@ -84,7 +81,7 @@ export async function sweepFailedEvents(
   processMessage: MessageProcessor,
   mintBearerToken: (() => string) | undefined,
 ): Promise<void> {
-  const events = channelDeliveryStore.getRetryableEvents();
+  const events = deliveryStatus.getRetryableEvents();
   if (events.length === 0) return;
 
   log.info({ count: events.length }, "Retrying failed channel inbound events");
@@ -92,7 +89,7 @@ export async function sweepFailedEvents(
   for (const event of events) {
     if (!event.rawPayload) {
       // No payload stored -- can't replay, move to dead letter
-      channelDeliveryStore.recordProcessingFailure(
+      deliveryStatus.recordProcessingFailure(
         event.id,
         new Error("No raw payload stored for replay"),
       );
@@ -103,7 +100,7 @@ export async function sweepFailedEvents(
     try {
       payload = JSON.parse(event.rawPayload) as Record<string, unknown>;
     } catch {
-      channelDeliveryStore.recordProcessingFailure(
+      deliveryStatus.recordProcessingFailure(
         event.id,
         new Error("Failed to parse stored raw payload"),
       );
@@ -117,7 +114,7 @@ export async function sweepFailedEvents(
       : undefined;
     const sourceChannel = parseChannelId(payload.sourceChannel);
     if (!sourceChannel) {
-      channelDeliveryStore.recordProcessingFailure(
+      deliveryStatus.recordProcessingFailure(
         event.id,
         new Error(`Invalid sourceChannel: ${String(payload.sourceChannel)}`),
       );
@@ -132,9 +129,7 @@ export async function sweepFailedEvents(
       | undefined;
     const assistantId =
       typeof payload.assistantId === "string" ? payload.assistantId : undefined;
-    // Backward-compat: events persisted before the guardianCtx → trustCtx
-    // rename still carry the old key name.
-    const rawTrustCtx = payload.trustCtx ?? payload.guardianCtx;
+    const rawTrustCtx = payload.trustCtx;
     const parsedTrustContext = parseTrustRuntimeContext(rawTrustCtx);
 
     // If the stored payload had guardian context data but it couldn't be parsed
@@ -147,7 +142,7 @@ export async function sweepFailedEvents(
         { eventId: event.id },
         "Stored trustCtx could not be parsed into canonical form; marking event as failed to prevent privilege escalation",
       );
-      channelDeliveryStore.markRetryableFailure(
+      deliveryStatus.markRetryableFailure(
         event.id,
         "Unparseable guardian context in stored payload — refusing to process without trust classification",
       );
@@ -195,8 +190,8 @@ export async function sweepFailedEvents(
         sourceChannel,
         sourceInterface,
       );
-      channelDeliveryStore.linkMessage(event.id, userMessageId);
-      channelDeliveryStore.markProcessed(event.id);
+      deliveryCrud.linkMessage(event.id, userMessageId);
+      deliveryStatus.markProcessed(event.id);
       log.info(
         { eventId: event.id },
         "Successfully replayed failed channel event",
@@ -216,7 +211,7 @@ export async function sweepFailedEvents(
           // previously tracked segment progress belongs to the old response and
           // must not carry over. Reset to 0 so we deliver all segments of the
           // new response.
-          channelDeliveryStore.updateDeliveredSegmentCount(event.id, 0);
+          deliveryChannels.updateDeliveredSegmentCount(event.id, 0);
           await deliverReplyViaCallback(
             event.conversationId,
             externalChatId,
@@ -226,17 +221,14 @@ export async function sweepFailedEvents(
             {
               startFromSegment: 0,
               onSegmentDelivered: (count) =>
-                channelDeliveryStore.updateDeliveredSegmentCount(
-                  event.id,
-                  count,
-                ),
+                deliveryChannels.updateDeliveredSegmentCount(event.id, count),
             },
           );
         }
       }
     } catch (err) {
       log.error({ err, eventId: event.id }, "Retry failed for channel event");
-      channelDeliveryStore.recordProcessingFailure(event.id, err);
+      deliveryStatus.recordProcessingFailure(event.id, err);
     }
   }
 }