@vellumai/assistant 0.10.4 → 0.10.5-dev.202607022329.d89bf2f

package/src/__tests__/call-setup-flow.test.ts

@@ -0,0 +1,311 @@
+import { describe, expect, test } from "bun:test";
+
+import {
+  CallSetupFlow,
+  type CallSetupFlowDeps,
+  UnsupportedSetupFlowError,
+} from "../calls/call-setup-flow.js";
+import type {
+  SetupFlowResult,
+  SetupFlowState,
+  SetupFlowTransport,
+} from "../calls/call-setup-flow-types.js";
+import type { MediaStreamOutput } from "../calls/media-stream-output.js";
+import type {
+  SetupOutcome,
+  SetupResolved,
+} from "../calls/relay-setup-router.js";
+import type { TrustContext } from "../daemon/trust-context.js";
+import type { TrustClass } from "../runtime/trust-class.js";
+
+// ---------------------------------------------------------------------------
+// Fixtures
+// ---------------------------------------------------------------------------
+
+const CALL_SESSION_ID = "call-session-1";
+const PHONE_NUMBER = "+15555550100";
+
+function makeResolved(trustClass: TrustClass = "guardian"): SetupResolved {
+  return {
+    assistantId: "self",
+    isInbound: true,
+    otherPartyNumber: PHONE_NUMBER,
+    actorTrust: {
+      canonicalSenderId: PHONE_NUMBER,
+      guardianBindingMatch: null,
+      memberRecord: null,
+      trustClass,
+      actorMetadata: {
+        identifier: PHONE_NUMBER,
+        displayName: undefined,
+        senderDisplayName: undefined,
+        memberDisplayName: undefined,
+        username: undefined,
+        channel: "phone",
+        trustStatus: trustClass,
+      },
+    },
+  };
+}
+
+function createFakeTransport() {
+  const spokenTokens: Array<{ token: string; last: boolean }> = [];
+  const endReasons: Array<string | undefined> = [];
+  const transport: SetupFlowTransport = {
+    sendTextToken: (token, last) => {
+      spokenTokens.push({ token, last });
+    },
+    endSession: (reason) => {
+      endReasons.push(reason);
+    },
+    requiresWavAudio: true,
+  };
+  return { transport, spokenTokens, endReasons };
+}
+
+function createFlow(overrides?: Partial<CallSetupFlowDeps>) {
+  const fake = createFakeTransport();
+  const spoken: string[] = [];
+  const sessionUpdates: Array<Record<string, unknown>> = [];
+  const events: Array<{
+    eventType: string;
+    payload?: Record<string, unknown>;
+  }> = [];
+  const results: SetupFlowResult[] = [];
+
+  const deps: CallSetupFlowDeps = {
+    speakSystemPrompt: async (text) => {
+      spoken.push(text);
+    },
+    updateCallSession: (_id, updates) => {
+      sessionUpdates.push(updates as Record<string, unknown>);
+    },
+    recordCallEvent: (_callSessionId, eventType, payload) => {
+      events.push({ eventType, payload });
+    },
+    onComplete: (result) => {
+      results.push(result);
+    },
+    ttsPlaybackDelayMs: 0,
+    attemptInviteCodeRedemption: async () => ({
+      outcome: "failure" as const,
+      ttsMessage: "unused",
+    }),
+    resolveGuardianLabel: () => "Bob",
+    resolveAssistantLabel: () => null,
+    getCallSession: () => ({ conversationId: "conv-1" }),
+    finalizeCall: () => {},
+    fireCallTranscriptNotifier: () => {},
+    resolveMidCallTrustContext: async () => ({
+      sourceChannel: "phone" as const,
+      trustClass: "trusted_contact" as const,
+    }),
+    ...overrides,
+  };
+
+  const flow = new CallSetupFlow(CALL_SESSION_ID, fake.transport, deps);
+  return { flow, ...fake, spoken, sessionUpdates, events, results };
+}
+
+const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("CallSetupFlow", () => {
+  describe("normal_call", () => {
+    test("completes with proceed-initial-greeting carrying the resolved trust", async () => {
+      const { flow, results, spoken, endReasons } = createFlow();
+      const resolved = makeResolved("guardian");
+
+      expect(flow.getState()).toBe("idle");
+      await flow.start({ action: "normal_call", isInbound: true }, resolved);
+
+      expect(flow.getState()).toBe("completed");
+      expect(results).toHaveLength(1);
+      const result = results[0];
+      expect(result.kind).toBe("proceed-initial-greeting");
+      if (result.kind !== "proceed-initial-greeting") {
+        throw new Error("expected proceed-initial-greeting");
+      }
+      expect(result.assistantId).toBe("self");
+      expect(result.trustContext.trustClass).toBe("guardian");
+      expect(result.trustContext.sourceChannel).toBe("phone");
+      expect(result.trustContext.requesterChatId).toBe(PHONE_NUMBER);
+
+      // No speech and no teardown on the normal path.
+      expect(spoken).toEqual([]);
+      expect(endReasons).toEqual([]);
+    });
+  });
+
+  describe("deny", () => {
+    const denyOutcome: SetupOutcome = {
+      action: "deny",
+      message: "This number is not authorized to use this assistant.",
+      logReason: "Inbound voice ACL: member policy deny",
+    };
+
+    test("records the ACL event, fails the session, speaks, and ends", async () => {
+      const { flow, results, spoken, events, sessionUpdates, endReasons } =
+        createFlow();
+      const resolved = makeResolved("unknown");
+
+      await flow.start(denyOutcome, resolved);
+
+      expect(events).toEqual([
+        {
+          eventType: "inbound_acl_denied",
+          payload: {
+            from: PHONE_NUMBER,
+            trustClass: "unknown",
+            channelId: undefined,
+            memberPolicy: undefined,
+          },
+        },
+      ]);
+      expect(sessionUpdates).toHaveLength(1);
+      expect(sessionUpdates[0].status).toBe("failed");
+      expect(sessionUpdates[0].lastError).toBe(denyOutcome.logReason);
+      expect(sessionUpdates[0].endedAt).toBeNumber();
+
+      expect(spoken).toEqual([denyOutcome.message]);
+      expect(flow.getState()).toBe("completed");
+      expect(results).toEqual([
+        { kind: "ended", reason: denyOutcome.logReason },
+      ]);
+
+      // Session teardown fires after the playback delay, not inline.
+      await sleep(0);
+      expect(endReasons).toEqual([denyOutcome.logReason]);
+    });
+
+    test("delays endSession until the playback delay elapses", async () => {
+      const { flow, endReasons } = createFlow({ ttsPlaybackDelayMs: 25 });
+
+      await flow.start(denyOutcome, makeResolved("unknown"));
+
+      expect(endReasons).toEqual([]);
+      await sleep(40);
+      expect(endReasons).toEqual([denyOutcome.logReason]);
+    });
+  });
+
+  describe("unsupported actions", () => {
+    test("throws UnsupportedSetupFlowError and stays idle", async () => {
+      const { flow, results } = createFlow();
+
+      await expect(
+        flow.start(
+          { action: "not_a_real_action" } as unknown as SetupOutcome,
+          makeResolved("unknown"),
+        ),
+      ).rejects.toBeInstanceOf(UnsupportedSetupFlowError);
+
+      expect(flow.getState()).toBe("idle");
+      expect(results).toEqual([]);
+    });
+  });
+
+  describe("lifecycle guards", () => {
+    test("start() may only run once", async () => {
+      const { flow } = createFlow();
+      const resolved = makeResolved();
+
+      await flow.start({ action: "normal_call", isInbound: true }, resolved);
+      await expect(
+        flow.start({ action: "normal_call", isInbound: true }, resolved),
+      ).rejects.toThrow("may only be called once");
+    });
+
+    test("start() during an in-flight deny path throws", async () => {
+      // The deny path awaits TTS before completing, so the flow is still
+      // in `idle` state while the first start() is in flight.
+      let release!: () => void;
+      const gate = new Promise<void>((resolve) => {
+        release = resolve;
+      });
+      const { flow } = createFlow({ speakSystemPrompt: () => gate });
+      const denyOutcome: SetupOutcome = {
+        action: "deny",
+        message: "Denied.",
+        logReason: "test deny",
+      };
+
+      const first = flow.start(denyOutcome, makeResolved("unknown"));
+      await expect(
+        flow.start(denyOutcome, makeResolved("unknown")),
+      ).rejects.toThrow("may only be called once");
+
+      release();
+      await first;
+    });
+
+    test("input methods are no-ops while idle and completed", async () => {
+      const { flow, results, spoken } = createFlow();
+
+      // Idle: inputs are swallowed.
+      flow.pushDtmfDigit("1");
+      flow.pushTranscriptFinal("hello");
+      expect(flow.getState()).toBe("idle");
+
+      await flow.start(
+        { action: "normal_call", isInbound: true },
+        makeResolved(),
+      );
+
+      // Completed: inputs are swallowed.
+      flow.pushDtmfDigit("2");
+      flow.pushTranscriptFinal("still here");
+      expect(flow.getState()).toBe("completed");
+      expect(results).toHaveLength(1);
+      expect(spoken).toEqual([]);
+    });
+  });
+
+  describe("type surfaces", () => {
+    test("MediaStreamOutput is assignable to SetupFlowTransport", () => {
+      // Compile-time assertion: the structural transport subset is
+      // satisfied by the media-stream output adapter.
+      const assertAssignable = (
+        output: MediaStreamOutput,
+      ): SetupFlowTransport => output;
+      expect(assertAssignable).toBeInstanceOf(Function);
+    });
+
+    test("all SetupFlowResult variants are representable", () => {
+      const trustContext: TrustContext = {
+        sourceChannel: "phone",
+        trustClass: "trusted_contact",
+      };
+      const variants: SetupFlowResult[] = [
+        { kind: "proceed-initial-greeting", assistantId: "self", trustContext },
+        {
+          kind: "proceed-post-verification-greeting",
+          assistantId: "self",
+          trustContext,
+        },
+        { kind: "proceed-handoff-spoken", assistantId: "self", trustContext },
+        { kind: "ended", reason: "test" },
+      ];
+      expect(variants.map((v) => v.kind)).toEqual([
+        "proceed-initial-greeting",
+        "proceed-post-verification-greeting",
+        "proceed-handoff-spoken",
+        "ended",
+      ]);
+    });
+
+    test("all SetupFlowState values are representable", () => {
+      const states: SetupFlowState[] = [
+        "idle",
+        "collecting_code",
+        "capturing_name",
+        "awaiting_guardian_decision",
+        "completed",
+      ];
+      expect(states).toHaveLength(5);
+    });
+  });
+});

package/src/__tests__/cancel-resolves-conversation-key.test.ts

@@ -51,7 +51,6 @@ mock.module("../daemon/handlers/conversations.js", () => ({
   switchConversation: async () => null,
   clearAllConversations: async () => 0,
   undoLastMessage: async () => null,
-  regenerateResponse: async () => null,
 }));
 
 import { getOrCreateConversation } from "../persistence/conversation-key-store.js";

package/src/__tests__/channel-guardian.test.ts

@@ -152,7 +152,6 @@ import {
   getPendingSession,
   isGuardian,
   resolveBootstrapToken,
-  revokeBinding as serviceRevokeBinding,
   updateSessionStatus as serviceUpdateSessionStatus,
   validateAndConsumeVerification,
 } from "../runtime/channel-verification-service.js";
@@ -607,9 +606,8 @@ describe("guardian identity check", () => {
       guardianDeliveryChatId: "chat-42",
     });
 
-    // The revoke is gateway-owned; serviceRevokeBinding's local teardown is a
-    // no-op shim. Stamp the local downgrade and assert the read reflects it.
-    serviceRevokeBinding("asst-1", "telegram");
+    // The revoke is gateway-owned. Stamp the local downgrade and assert the
+    // read reflects it.
     revokeGuardianChannelLocally("telegram");
     expect(await getGuardianBinding("asst-1", "telegram")).toBeNull();
   });
@@ -1478,9 +1476,8 @@ describe("voice guardian identity and revocation", () => {
       guardianDeliveryChatId: "voice-chat-1",
     });
 
-    // The revoke is gateway-owned; serviceRevokeBinding's local teardown is a
-    // no-op shim. Stamp the local downgrade and assert the read reflects it.
-    serviceRevokeBinding("asst-1", "phone");
+    // The revoke is gateway-owned. Stamp the local downgrade and assert the
+    // read reflects it.
     revokeGuardianChannelLocally("phone");
     expect(await getGuardianBinding("asst-1", "phone")).toBeNull();
   });

package/src/__tests__/channel-readiness-service.test.ts

@@ -17,12 +17,6 @@ mock.module("../calls/twilio-rest.js", () => ({
   hasTwilioCredentials: () => mockHasTwilioCredentials,
 }));
 
-mock.module("../channels/config.js", () => ({
-  getChannelInvitePolicy: () => ({
-    codeRedemptionEnabled: true,
-  }),
-}));
-
 mock.module("../config/env.js", () => ({
   getIngressPublicBaseUrl: () => undefined,
 }));

package/src/__tests__/channel-readiness-slack-remote.test.ts

@@ -35,10 +35,6 @@ mock.module("../config/env-registry.js", () => ({
   getIsPlatform: () => false,
 }));
 
-mock.module("../channels/config.js", () => ({
-  getChannelInvitePolicy: () => ({ codeRedemptionEnabled: false }),
-}));
-
 mock.module("../calls/twilio-rest.js", () => ({
   hasTwilioCredentials: () => false,
 }));

package/src/__tests__/channel-retry-sweep.test.ts

@@ -493,7 +493,7 @@ describe("channel-retry-sweep", () => {
     ).toBe("assistant-delivery-fails");
   });
 
-  test("Slack DM processing retries skip previously delivered live text responses", async () => {
+  test("Slack DM processing retry reconciles into the streamed message without opening a second stream", async () => {
     const inbound = deliveryCrud.recordInbound(
       "slack",
       "D-LIVE-RETRY",
@@ -511,7 +511,8 @@ describe("channel-retry-sweep", () => {
         sourceChannel: "slack",
         requesterChatId: "D-LIVE-RETRY",
       },
-      slackDmLiveDeliveredTextResponseIndexes: [1],
+      // A prior attempt streamed a message before failing.
+      slackStreamMessageTs: "1700000000.000044",
     });
 
     const db = getDb();
@@ -527,28 +528,9 @@ describe("channel-retry-sweep", () => {
     await sweepFailedEvents(async (conversationId, _content, options) => {
       options?.onEvent?.({
         type: "assistant_text_delta",
-        text: "Already delivered live response.",
+        text: "Reprocessed response.",
         conversationId,
       });
-      options?.onEvent?.({
-        type: "tool_use_start",
-        toolName: "web_search",
-        input: { query: "one" },
-        conversationId,
-        toolUseId: "toolu_1",
-      });
-      options?.onEvent?.({
-        type: "assistant_text_delta",
-        text: "New live response.",
-        conversationId,
-      });
-      options?.onEvent?.({
-        type: "tool_use_start",
-        toolName: "web_search",
-        input: { query: "two" },
-        conversationId,
-        toolUseId: "toolu_2",
-      });
       options?.onEvent?.({
         type: "message_complete",
         conversationId,
@@ -575,11 +557,9 @@ describe("channel-retry-sweep", () => {
       ? (JSON.parse(row.rawPayload) as Record<string, unknown>)
       : {};
 
-    expect(
-      liveDeliveryCalls.map((entry) => entry.payload.text).filter(Boolean),
-    ).toEqual(["New live response."]);
-    expect(rawPayload.slackDmLiveDeliveredTextResponseIndexes).toEqual([1, 2]);
-    expect(rawPayload.replyMessageId).toBe("assistant-live-retry-final");
+    // A retry never streams; durable delivery edits the prior streamed message
+    // in place from the first segment, so the reply is not duplicated.
+    expect(liveDeliveryCalls).toEqual([]);
     expect(deliveryCalls).toEqual([
       {
         conversationId: inbound.conversationId,
@@ -587,13 +567,17 @@ describe("channel-retry-sweep", () => {
         callbackUrl: "https://example.test/deliver/slack",
         assistantId: undefined,
         messageId: "assistant-live-retry-final",
-        startFromSegment: 2,
+        startFromSegment: 0,
+        messageTs: "1700000000.000044",
       },
     ]);
+    expect(rawPayload.replyMessageId).toBe("assistant-live-retry-final");
+    expect(rawPayload.slackStreamMessageTs).toBe("1700000000.000044");
     expect(row?.processingStatus).toBe("processed");
+    expect(row?.deliveryStatus).toBe("delivered");
   });
 
-  test("Slack DM processing retries resume final delivery after live text", async () => {
+  test("Slack DM processing retry with no prior stream delivers the full reply normally", async () => {
     const inbound = deliveryCrud.recordInbound(
       "slack",
       "D-LIVE-RETRY-SAME-REPLY",
@@ -622,10 +606,6 @@ describe("channel-retry-sweep", () => {
       })
       .where(eq(channelInboundEvents.id, inbound.eventId))
       .run();
-    deliverChannelReplyImpl = async () => ({
-      ok: true,
-      ts: "1700000000.000044",
-    });
 
     await sweepFailedEvents(async (conversationId, _content, options) => {
       options?.onEvent?.({
@@ -633,13 +613,6 @@ describe("channel-retry-sweep", () => {
         text: "Live retry response.",
         conversationId,
       });
-      options?.onEvent?.({
-        type: "tool_use_start",
-        toolName: "web_search",
-        input: { query: "example" },
-        conversationId,
-        toolUseId: "toolu_1",
-      });
       options?.onEvent?.({
         type: "message_complete",
         conversationId,
@@ -666,9 +639,7 @@ describe("channel-retry-sweep", () => {
       ? (JSON.parse(row.rawPayload) as Record<string, unknown>)
       : {};
 
-    expect(
-      liveDeliveryCalls.map((entry) => entry.payload.text).filter(Boolean),
-    ).toEqual(["Live retry response."]);
+    expect(liveDeliveryCalls).toEqual([]);
     expect(deliveryCalls).toEqual([
       {
         conversationId: inbound.conversationId,
@@ -676,17 +647,16 @@ describe("channel-retry-sweep", () => {
         callbackUrl: "https://example.test/deliver/slack",
         assistantId: undefined,
         messageId: "assistant-live-retry-same-reply",
-        startFromSegment: 1,
-        messageTs: "1700000000.000044",
+        startFromSegment: 0,
       },
     ]);
-    expect(rawPayload.slackDmLiveDeliveredTextResponseIndexes).toEqual([1]);
+    expect(rawPayload.slackStreamMessageTs).toBeUndefined();
     expect(rawPayload.replyMessageId).toBe("assistant-live-retry-same-reply");
     expect(row?.processingStatus).toBe("processed");
     expect(row?.deliveryStatus).toBe("delivered");
   });
 
-  test("Slack DM processing retries persist live delivery progress before final delivery failures", async () => {
+  test("Slack DM processing retry preserves the streamed message ts when delivery fails again", async () => {
     const inbound = deliveryCrud.recordInbound(
       "slack",
       "D-LIVE-RETRY-FINAL-FAILS",
@@ -704,6 +674,7 @@ describe("channel-retry-sweep", () => {
         sourceChannel: "slack",
         requesterChatId: "D-LIVE-RETRY-FINAL-FAILS",
       },
+      slackStreamMessageTs: "1700000000.000055",
     });
 
     const db = getDb();
@@ -715,10 +686,6 @@ describe("channel-retry-sweep", () => {
       })
       .where(eq(channelInboundEvents.id, inbound.eventId))
       .run();
-    deliverChannelReplyImpl = async () => ({
-      ok: true,
-      ts: "1700000000.000055",
-    });
     deliverReplyViaCallbackImpl = async () => {
       throw new Error("fetch failed before progress callback");
     };
@@ -729,13 +696,6 @@ describe("channel-retry-sweep", () => {
         text: "Live retry response.",
         conversationId,
       });
-      options?.onEvent?.({
-        type: "tool_use_start",
-        toolName: "web_search",
-        input: { query: "example" },
-        conversationId,
-        toolUseId: "toolu_1",
-      });
       options?.onEvent?.({
         type: "message_complete",
         conversationId,
@@ -762,9 +722,7 @@ describe("channel-retry-sweep", () => {
       ? (JSON.parse(row.rawPayload) as Record<string, unknown>)
       : {};
 
-    expect(
-      liveDeliveryCalls.map((entry) => entry.payload.text).filter(Boolean),
-    ).toEqual(["Live retry response."]);
+    expect(liveDeliveryCalls).toEqual([]);
     expect(deliveryCalls).toEqual([
       {
         conversationId: inbound.conversationId,
@@ -772,12 +730,12 @@ describe("channel-retry-sweep", () => {
         callbackUrl: "https://example.test/deliver/slack",
         assistantId: undefined,
         messageId: "assistant-live-retry-final-fails",
-        startFromSegment: 1,
+        startFromSegment: 0,
         messageTs: "1700000000.000055",
       },
     ]);
-    expect(rawPayload.slackDmLiveDeliveredTextResponseIndexes).toEqual([1]);
-    expect(row?.deliveredSegmentCount).toBe(1);
+    // The streamed ts survives so a later retry still reconciles in place.
+    expect(rawPayload.slackStreamMessageTs).toBe("1700000000.000055");
     expect(row?.deliveryStatus).toBe("failed");
   });
 
@@ -836,6 +794,60 @@ describe("channel-retry-sweep", () => {
     expect(row?.retryAfter).toBeNull();
   });
 
+  test("delivery retry edits a prior streamed message in place instead of posting a duplicate", async () => {
+    const inbound = deliveryCrud.recordInbound(
+      "slack",
+      "D-DELIVERY-ONLY-STREAM",
+      "msg-delivery-only-stream",
+    );
+    deliveryCrud.storePayload(inbound.eventId, {
+      content: "already processed",
+      sourceChannel: "slack",
+      interface: "slack",
+      externalChatId: "D-DELIVERY-ONLY-STREAM",
+      replyCallbackUrl: "https://example.test/deliver/slack",
+      assistantId: "assistant-1",
+      replyMessageId: "assistant-delivery-only-stream",
+      // A prior attempt streamed a message, then delivery failed before any
+      // durable segment landed.
+      slackStreamMessageTs: "1700000000.000077",
+    });
+
+    const db = getDb();
+    db.update(channelInboundEvents)
+      .set({
+        processingStatus: "processed",
+        deliveryStatus: "failed",
+        processingAttempts: 1,
+        retryAfter: Date.now() - 1,
+        deliveredSegmentCount: 0,
+      })
+      .where(eq(channelInboundEvents.id, inbound.eventId))
+      .run();
+
+    await sweepFailedEvents(async () => {
+      throw new Error("processMessage should not be called");
+    });
+
+    const row = db
+      .select()
+      .from(channelInboundEvents)
+      .where(eq(channelInboundEvents.id, inbound.eventId))
+      .get();
+    expect(deliveryCalls).toEqual([
+      {
+        conversationId: inbound.conversationId,
+        externalChatId: "D-DELIVERY-ONLY-STREAM",
+        callbackUrl: "https://example.test/deliver/slack",
+        assistantId: "assistant-1",
+        messageId: "assistant-delivery-only-stream",
+        startFromSegment: 0,
+        messageTs: "1700000000.000077",
+      },
+    ]);
+    expect(row?.deliveryStatus).toBe("delivered");
+  });
+
   test("delivery retry resolves missing reply id from the linked user turn", async () => {
     const inbound = deliveryCrud.recordInbound(
       "telegram",