@vellumai/assistant 0.11.2 → 0.11.3-staging.2

package/src/live-voice/live-voice-photo.ts

@@ -0,0 +1,169 @@
+/**
+ * Persisting a photo taken during a live-voice call.
+ *
+ * A photo lands in the conversation as its own user message, the moment the
+ * shutter fires, and **runs no turn**. That single choice is what makes the
+ * order of shutter and speech irrelevant: whatever the user says next, before
+ * or after the snap, is answered by a model whose history already contains the
+ * image.
+ *
+ * The alternatives were both worse and both were tried. Attaching the photo to
+ * the *next* spoken turn strands it whenever the user speaks first: the
+ * question "what's this?" dispatches without an image and the photo waits for
+ * a sentence that has already been said. Dispatching a turn *for* the photo
+ * races the sentence the user is in the middle of saying, so the assistant
+ * answers the picture and the words separately.
+ *
+ * The cost, accepted: media survives a context-overflow retry only on the most
+ * recent user message (`conversation-media-retry.ts`), so on a long call a
+ * photo can be stripped where one riding the spoken turn would have survived.
+ * Stranding is the worse failure, and it happens every time rather than only
+ * under overflow.
+ */
+
+import { v7 as uuidv7 } from "uuid";
+
+import { persistQueuedMessageBody } from "../daemon/conversation-messaging.js";
+import { getOrCreateConversation } from "../daemon/conversation-store.js";
+import {
+  getAttachmentsByIds,
+  getSourcePathsForAttachments,
+} from "../persistence/attachments-store.js";
+import { recordConversationPersistedSeq } from "../persistence/conversation-crud.js";
+import { broadcastMessage } from "../runtime/assistant-event-hub.js";
+import { getCurrentSeq } from "../runtime/assistant-stream-state.js";
+import { publishConversationMessagesChanged } from "../runtime/sync/resource-sync-events.js";
+import { getLogger } from "../util/logger.js";
+
+const log = getLogger("live-voice-photo");
+
+/**
+ * How long to wait for an in-flight turn before giving up on a photo.
+ *
+ * Persisting takes the conversation's processing lock, which a running turn
+ * holds for as long as it runs, tools included. The wait is generous because
+ * the alternative is dropping a photo the user watched themselves take, and
+ * the photo is not urgent: nothing is blocked on it except the next thing they
+ * say.
+ */
+const PROCESSING_WAIT_MS = 30_000;
+const PROCESSING_POLL_MS = 100;
+
+/** What the user message says. The image blocks carry the actual content. */
+const PHOTO_MESSAGE_CONTENT = "[photo]";
+
+export interface LiveVoicePhotoResult {
+  readonly ok: boolean;
+  readonly messageId?: string;
+}
+
+/**
+ * Hydrate attachment ids into the shape `persistQueuedMessageBody` stores.
+ * Mirrors the HTTP send path's own `resolveAttachments`, so a photo taken
+ * mid-call is stored exactly like one attached to a typed message.
+ */
+function resolvePhotoAttachments(attachmentIds: string[]) {
+  const resolved = getAttachmentsByIds(attachmentIds, {
+    hydrateFileData: true,
+  });
+  const sourcePaths = getSourcePathsForAttachments(attachmentIds);
+  return resolved.map((a) => ({
+    id: a.id,
+    filename: a.originalFilename,
+    mimeType: a.mimeType,
+    data: a.dataBase64,
+    ...(sourcePaths.has(a.id) ? { filePath: sourcePaths.get(a.id) } : {}),
+  }));
+}
+
+/** Resolve once the conversation is not mid-turn, or false on timeout. */
+async function waitForIdle(conversation: {
+  isProcessing: () => boolean;
+}): Promise<boolean> {
+  const deadline = Date.now() + PROCESSING_WAIT_MS;
+  while (conversation.isProcessing()) {
+    if (Date.now() >= deadline) {
+      return false;
+    }
+    await new Promise((resolve) => setTimeout(resolve, PROCESSING_POLL_MS));
+  }
+  return true;
+}
+
+/**
+ * Persist a photo into the conversation as a user message, running no turn.
+ *
+ * Takes and releases the processing lock the way the built-in slash commands
+ * do: they are the existing precedent for "persist a user message and answer
+ * without the agent loop", and the lock is what keeps this write from
+ * interleaving with a turn's own persist.
+ *
+ * Never throws. A photo that cannot be stored must not take the call down with
+ * it, and the caller reports the failure to the user instead.
+ */
+export async function persistLiveVoicePhoto(
+  conversationId: string,
+  attachmentId: string,
+): Promise<LiveVoicePhotoResult> {
+  try {
+    const attachments = resolvePhotoAttachments([attachmentId]);
+    if (attachments.length === 0) {
+      log.warn({ attachmentId }, "Live-voice photo attachment did not resolve");
+      return { ok: false };
+    }
+
+    const conversation = await getOrCreateConversation(conversationId);
+
+    // A turn holds the lock for its whole run. Waiting rather than queueing:
+    // the conversation's queue drains into a turn, which is the one thing this
+    // must not cause.
+    if (!(await waitForIdle(conversation))) {
+      log.warn(
+        { conversationId, attachmentId },
+        "Live-voice photo timed out waiting for the conversation to go idle",
+      );
+      return { ok: false };
+    }
+
+    conversation.setProcessing(true);
+    try {
+      const persisted = await persistQueuedMessageBody(conversation, {
+        content: PHOTO_MESSAGE_CONTENT,
+        attachments,
+        requestId: uuidv7(),
+        metadata: {
+          // Marks the row as something the user did on a call rather than
+          // typed, the same way a voice turn's own user message is marked.
+          voiceSessionTurn: true,
+          livePhoto: true,
+        },
+      });
+
+      // The row exists but no turn will announce it, so the clients that
+      // render this conversation have to be told directly, or the photo does
+      // not appear until something else forces a refetch.
+      broadcastMessage({
+        type: "user_message_echo",
+        text: PHOTO_MESSAGE_CONTENT,
+        conversationId,
+        messageId: persisted.id,
+      });
+      recordConversationPersistedSeq(conversationId, getCurrentSeq());
+      publishConversationMessagesChanged(conversationId);
+
+      return { ok: true, messageId: persisted.id };
+    } finally {
+      conversation.setProcessing(false);
+      // Anything queued behind the lock we just held still has to run. Without
+      // this a message queued during the photo's write sits until the next
+      // turn ends.
+      void conversation.kickDrainQueue("loop_complete", "live_voice_photo");
+    }
+  } catch (err) {
+    log.warn(
+      { err, conversationId, attachmentId },
+      "Failed to persist a live-voice photo",
+    );
+    return { ok: false };
+  }
+}

package/src/live-voice/live-voice-session.ts

@@ -38,6 +38,10 @@ import {
 import { ABORT_WATCHDOG_MS } from "../daemon/abort-watchdog.js";
 import { isRefusedInReadOnlyPass } from "../daemon/conversation-tool-setup.js";
 import type { TrustContext } from "../daemon/trust-context-types.js";
+import {
+  recordLiveVoiceSessionEnded,
+  recordLiveVoiceSessionStarted,
+} from "../onboarding/onboarding-events-store.js";
 import { isInstalledStaticSkillLoad } from "../permissions/checker.js";
 import { ensureConversationExists } from "../persistence/conversation-crud.js";
 import {
@@ -54,6 +58,7 @@ import type {
   SttStreamServerEvent,
 } from "../stt/types.js";
 import { getSubagentManager } from "../subagent/index.js";
+import { liveVoiceEndScreen } from "../telemetry/live-voice-funnel.js";
 import { getToolOwner } from "../tools/registry.js";
 import { extractSpeakableSegments } from "../tts/speakable-segments.js";
 import { createAbortReason } from "../util/abort-reasons.js";
@@ -84,6 +89,7 @@ import {
   type LiveVoiceTurnSeedMarks,
   type VoiceEndpointAction,
 } from "./live-voice-metrics.js";
+import { persistLiveVoicePhoto } from "./live-voice-photo.js";
 import {
   type LiveVoiceSession as LiveVoiceSessionContract,
   type LiveVoiceSessionCloseReason,
@@ -97,6 +103,7 @@ import type {
 } from "./live-voice-tts.js";
 import { pickProgressPhrase } from "./progress-phrases.js";
 import {
+  type LiveVoiceClientAttachImageFrame,
   type LiveVoiceClientFrame,
   type LiveVoiceClientUpdateConfigFrame,
   LiveVoiceProtocolErrorCode,
@@ -972,6 +979,16 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
   private outboundFrames: Promise<void> = Promise.resolve();
   private activeAssistantTurn: ActiveAssistantTurn | null = null;
   private sessionEndMetricsEmitted = false;
+  /**
+   * Protocol error code of the failure that killed the session, latched by
+   * {@link sendFrame} when an error frame goes out on an already-`failed`
+   * session. Both fatal paths (`failStartup` before `ready`, a failed
+   * utterance arm after it) set `state = "failed"` before sending, and no
+   * other error frame does, so this catches exactly the session-ending
+   * failures and ignores the recoverable mid-session ones. `null` on a
+   * session that never failed.
+   */
+  private failureCode: LiveVoiceProtocolErrorCode | null = null;
   // Non-null iff the start frame requested turnDetection "server_vad".
   private readonly turnDetector: MediaTurnDetector | null;
   // Energy gate for server-VAD speech classification; undefined defers to
@@ -1184,6 +1201,12 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
       return;
     }
 
+    // Before the preflight, not after: a session rejected for missing
+    // credentials is precisely the one the failure rate needs to count, and
+    // recording the start only once `ready` goes out would hide every such
+    // session from both the numerator and the denominator.
+    recordLiveVoiceSessionStarted(this.context.sessionId);
+
     if (this.resolveCredentialReadiness) {
       const readiness = await this.resolveCredentialReadiness();
       if (readiness.status === "not-ready") {
@@ -1237,9 +1260,44 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
       case "update_config":
         this.applyConfigUpdate(frame);
         return;
+      case "attach_image":
+        this.persistPhoto(frame);
+        return;
     }
   }
 
+  /**
+   * Persist a photo taken mid-call into the conversation, running no turn.
+   *
+   * Fire-and-forget on purpose: the persist waits out any in-flight turn, and
+   * the socket must keep pumping audio meanwhile. The client already showed a
+   * thumbnail from the local frame, so nothing on screen is waiting on this.
+   *
+   * The photo becomes its own user message rather than riding the next spoken
+   * turn, which is what makes shutter-then-speak and speak-then-shutter
+   * behave the same: either way the model's history has the image by the time
+   * it answers. See `live-voice-photo.ts` for the full reasoning.
+   */
+  private persistPhoto(frame: LiveVoiceClientAttachImageFrame): void {
+    void persistLiveVoicePhoto(this.conversationId, frame.attachmentId).then(
+      (result) => {
+        if (!result.ok && !this.isClosed) {
+          void this.sendFrame({
+            type: "error",
+            code: LiveVoiceProtocolErrorCode.InvalidFrame,
+            message: "Could not attach that photo to the conversation.",
+            // Names the photo as the casualty so the client can retract the
+            // thumbnail it already showed, rather than filing this with the
+            // transient transcriber and TTS blips that share `recoverable`.
+            frameType: "attach_image",
+            // The session is fine; only this photo failed.
+            recoverable: true,
+          });
+        }
+      },
+    );
+  }
+
   /**
    * Apply a mid-session `update_config` frame: retune the live turn detector's
    * pause ("pause before reply") and/or the barge-in guard ("interrupt
@@ -1261,11 +1319,24 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
     await this.handleAudio(Buffer.from(chunk));
   }
 
-  async close(_reason: LiveVoiceSessionCloseReason): Promise<void> {
+  async close(reason: LiveVoiceSessionCloseReason): Promise<void> {
     if (this.isClosed) {
       return;
     }
 
+    // Recorded first, and independently of `shouldEmitSessionEndMetrics`
+    // below: that flag governs the client-facing `metrics` frame, and a
+    // failed session (which suppresses the frame) is the one whose end
+    // telemetry matters most. Session duration downstream is this row's
+    // `recorded_at` minus the started row's, so it must be written before the
+    // teardown below, which awaits a pending continuation and can run long.
+    const failed = this.state === "failed";
+    recordLiveVoiceSessionEnded({
+      sessionId: this.context.sessionId,
+      screen: liveVoiceEndScreen(reason, failed ? this.failureCode : null),
+      outcome: failed ? "failed" : "completed",
+    });
+
     const shouldEmitSessionEndMetrics = this.state !== "failed";
     this.state = "closed";
     // Retire the island before the teardown below starts awaiting things. A
@@ -2864,8 +2935,9 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
   ): void {
     turn.speculativePending = false;
     // The dispatch is being unwound, so the barge-in merge note, the finished
-    // continuation's answer, and its queued announcement all go back to the
-    // session — the turn that would have delivered them is gone.
+    // continuation's answer, its queued announcement, and any photos it claimed
+    // all go back to the session. The turn that would have delivered them is
+    // gone, and the utterance they belong to is about to be sent by another.
     this.restorePendingTurnContext(turn);
     // Latched before the handle check: when the discard beats the bridge
     // handle's resolution (startVoiceTurn still persisting), the handle's
@@ -3807,8 +3879,20 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
         voiceSessionId: this.context.sessionId,
         userMessageChannel: "vellum",
         assistantMessageChannel: "vellum",
+        // Fixed, and NOT the originating client: this pair resolves the turn's
+        // channel capabilities, where `macos` is what grants a live-voice turn
+        // desktop UI and dynamic surfaces. Reporting the true client here would
+        // strip `supportsDynamicUi` from every iOS session: a behavior change
+        // wearing an attribution fix's clothes. The originating client travels
+        // as telemetry instead, on `voiceTelemetry` below.
         userMessageInterface: "macos",
         assistantMessageInterface: "macos",
+        voiceTelemetry: {
+          sessionId: this.context.sessionId,
+          ...(this.context.startFrame.client
+            ? { client: this.context.startFrame.client }
+            : {}),
+        },
         voiceControlPrompt: buildVoiceControlPrompt(activeTurn, {
           ...(leg.frontDoor !== undefined ? { frontDoor: leg.frontDoor } : {}),
         }),
@@ -5506,6 +5590,13 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
     // method, and a per-call-site hook would drift from it on the first frame
     // anyone added. Fire-and-forget by contract — see the reporter.
     this.liveActivityReporter.report(frame);
+    // Latched here for the same reason: both fatal paths mark the session
+    // `failed` and then send their error frame through this method, so the
+    // code that ended the session is readable at close without either path
+    // having to remember to stash it.
+    if (frame.type === "error" && this.state === "failed") {
+      this.failureCode ??= frame.code;
+    }
     let sent = false;
     this.outboundFrames = this.outboundFrames
       .catch(() => {})
@@ -5675,6 +5766,12 @@ export async function defaultSpawnBackgroundContinuation(args: {
       objective: args.objective,
       fork: true,
       sendResultToUser: false,
+      // Distinct spawn mode so this unattended continuation is separable in
+      // cost telemetry from a tool-initiated fork. Mechanically both are
+      // forks, but they come from different call sites with different cost
+      // profiles, and lumping them together is what made delegated spend
+      // opaque in the first place.
+      spawnMode: "voice_continuation",
       // Full subagent abilities: the continuation runs like any other
       // background subagent, so it can genuinely finish build-shaped work
       // (JARVIS-1354). Side effects are governed by the standard
@@ -5735,7 +5832,14 @@ async function defaultStartVoiceTurn(
   // inside `startVoiceTurn` trips `FOREIGN KEY constraint failed`. Ensure it
   // exists (idempotent) before persisting. Lives in the production wiring, not
   // the session state machine, so session unit tests stay DB-free.
-  const createdConversation = ensureConversationExists(options.conversationId);
+  // Native: this is the local live-voice session, which adopts a conversation
+  // id the app supplied. Its trust context resolves through
+  // `resolveLocalLiveVoiceTrustContext`, and a phone call reaches the assistant
+  // through the telephony path rather than here.
+  const createdConversation = ensureConversationExists(
+    options.conversationId,
+    "vellum",
+  );
   if (createdConversation) {
     // The row was created outside the normal send-message route, which is where
     // sibling clients/sidebars learn about a new conversation. Emit the same

package/src/live-voice/protocol.ts

@@ -1,3 +1,5 @@
+import { type ClientOs, parseClientOs } from "../channels/types.js";
+
 const LIVE_VOICE_CLIENT_FRAME_TYPES = [
   "start",
   "audio",
@@ -5,6 +7,7 @@ const LIVE_VOICE_CLIENT_FRAME_TYPES = [
   "interrupt",
   "end",
   "update_config",
+  "attach_image",
 ] as const;
 
 type LiveVoiceClientFrameType = (typeof LIVE_VOICE_CLIENT_FRAME_TYPES)[number];
@@ -98,6 +101,21 @@ export interface LiveVoiceClientStartFrame {
    * [{@link MIN_BARGE_IN_MIN_SPEECH_MS}, {@link MAX_BARGE_IN_MIN_SPEECH_MS}].
    */
   readonly bargeInMinSpeechMs?: number;
+  /**
+   * Which client opened the session. Absent from clients that predate the
+   * field, in which case the originating client is simply unknown.
+   *
+   * A {@link ClientOs}, not an `InterfaceId`, and deliberately so: the iOS and
+   * macOS apps run the same web bundle over the same transport, so the thing
+   * that actually differs between them is the OS surface. `ClientOs` is also
+   * the vocabulary that is barred by contract from answering transport
+   * questions (see `channels/types.ts`), which is the invariant wanted here:
+   * this value is **analytics only**. It rides the voice turn's telemetry
+   * `client` bag (see `voice-session-bridge.ts`) and never reaches
+   * `userMessageInterface`, which feeds `resolveChannelCapabilities` and is
+   * load-bearing for what a voice turn may do.
+   */
+  readonly client?: ClientOs;
 }
 
 /**
@@ -141,13 +159,35 @@ export interface LiveVoiceClientUpdateConfigFrame {
   readonly bargeInMinSpeechMs?: number;
 }
 
+/**
+ * A photo the user took mid-call, already uploaded over the normal attachment
+ * route (`POST /v1/assistants/{id}/attachments`). Only the resulting id
+ * travels here.
+ *
+ * The bytes deliberately do not: the upload endpoint already normalizes HEIF,
+ * caps size, and stores the blob, and routing an image through this socket
+ * would duplicate all of it on a transport tuned for 50 ms audio frames.
+ *
+ * The id is *parked*, not dispatched. It rides the next turn's own user
+ * message (see {@link LiveVoiceSession}'s pending-attachment handling), so the
+ * photo and the words spoken about it are one message rather than two, which
+ * is what lets "what's this?" resolve, and what keeps the image attached to the
+ * newest user message, the only one a context-overflow retry preserves media on
+ * (`conversation-media-retry.ts`).
+ */
+export interface LiveVoiceClientAttachImageFrame {
+  readonly type: "attach_image";
+  readonly attachmentId: string;
+}
+
 export type LiveVoiceClientFrame =
   | LiveVoiceClientStartFrame
   | LiveVoiceClientAudioFrame
   | LiveVoiceClientPttReleaseFrame
   | LiveVoiceClientInterruptFrame
   | LiveVoiceClientEndFrame
-  | LiveVoiceClientUpdateConfigFrame;
+  | LiveVoiceClientUpdateConfigFrame
+  | LiveVoiceClientAttachImageFrame;
 
 interface LiveVoiceBinaryAudioFrame {
   readonly type: "binary_audio";
@@ -337,6 +377,19 @@ export interface LiveVoiceErrorServerFrame extends LiveVoiceServerFrameBase {
   readonly type: "error";
   readonly code: LiveVoiceProtocolErrorCode;
   readonly message: string;
+  /**
+   * The client frame this error is about, when the failure was a parse or
+   * validation failure of a specific frame. Absent otherwise, and absent from
+   * daemons predating the field.
+   *
+   * It exists so an `unknown_type` is attributable. A client that sends more
+   * than one optional frame (today: `update_config` and `attach_image`) gets
+   * the same code for either, and without this has to assume which one was
+   * refused. The wrong assumption is silent in both directions: settings stop
+   * applying for a session, or a photo the user watched themselves take is
+   * dropped with nothing said.
+   */
+  readonly frameType?: string;
   /**
    * True when the session continues past the error (e.g. a transient
    * transcriber blip or one failed TTS segment). Absent (including on frames
@@ -469,9 +522,38 @@ export function validateLiveVoiceClientFrame(
       return { ok: true, frame: { type: "end" } };
     case "update_config":
       return validateUpdateConfigFrame(value);
+    case "attach_image":
+      return validateAttachImageFrame(value);
   }
 }
 
+function validateAttachImageFrame(
+  value: Record<string, unknown>,
+): LiveVoiceParseResult<LiveVoiceClientAttachImageFrame> {
+  if (!("attachmentId" in value)) {
+    return protocolError(
+      "missing_required_field",
+      "attach_image frame is missing required field attachmentId",
+      "attachmentId",
+      "attach_image",
+    );
+  }
+
+  if (!isNonEmptyString(value.attachmentId)) {
+    return protocolError(
+      "invalid_field",
+      "attach_image frame field attachmentId must be a non-empty string",
+      "attachmentId",
+      "attach_image",
+    );
+  }
+
+  return {
+    ok: true,
+    frame: { type: "attach_image", attachmentId: value.attachmentId },
+  };
+}
+
 function validateUpdateConfigFrame(
   value: Record<string, unknown>,
 ): LiveVoiceParseResult<LiveVoiceClientUpdateConfigFrame> {
@@ -642,6 +724,11 @@ function validateStartFrame(
     );
   }
 
+  // An unrecognized client is dropped rather than rejected: the field is an
+  // analytics dimension, and failing a session's startup over it would trade a
+  // gap in a chart for a user who cannot talk to their assistant.
+  const client = parseClientOs(value.client);
+
   return {
     ok: true,
     frame: {
@@ -649,6 +736,7 @@ function validateStartFrame(
       ...(typeof value.conversationId === "string"
         ? { conversationId: value.conversationId }
         : {}),
+      ...(client ? { client } : {}),
       audio: audioConfig.frame,
       ...(isLiveVoiceTurnDetectionMode(value.turnDetection)
         ? { turnDetection: value.turnDetection }

package/src/mcp/client.ts

@@ -3,6 +3,7 @@ import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
 import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import type { ToolAnnotations } from "@modelcontextprotocol/sdk/types.js";
 
 import { getIsPlatform } from "../config/env-registry.js";
 import type { McpTransport } from "../config/schemas/mcp.js";
@@ -33,10 +34,18 @@ function normalizeInputSchema(
   return { type: "object", properties: {} };
 }
 
+/**
+ * Behavioral hints a server may attach to a tool (MCP `ToolAnnotations`).
+ * Self-reported by the server, so consumers treat them as hints rather than
+ * guarantees.
+ */
+export type McpToolAnnotations = ToolAnnotations;
+
 export interface McpToolInfo {
   name: string;
   description: string;
   inputSchema: Record<string, unknown>;
+  annotations?: McpToolAnnotations;
 }
 
 export interface McpCallResult {
@@ -197,6 +206,7 @@ export class McpClient {
       name: tool.name,
       description: tool.description ?? "",
       inputSchema: normalizeInputSchema(tool.inputSchema, tool.name),
+      annotations: tool.annotations,
     }));
   }
 

package/src/messaging/providers/__tests__/callback-routing.test.ts

@@ -10,11 +10,14 @@ describe("channelForCallback", () => {
     expect(channelForCallback("http://gw/deliver/telegram")).toBe("telegram");
     expect(channelForCallback("http://gw/deliver/whatsapp")).toBe("whatsapp");
     expect(channelForCallback("http://gw/deliver/a2a?taskId=t1")).toBe("a2a");
+    expect(channelForCallback("http://gw/deliver/discord?threadId=T1")).toBe(
+      "discord",
+    );
   });
 
   test("returns undefined for channels not delivered directly", () => {
-    expect(channelForCallback("http://gw/deliver/discord")).toBeUndefined();
     expect(channelForCallback("http://gw/deliver/phone")).toBeUndefined();
+    expect(channelForCallback("http://gw/deliver/email")).toBeUndefined();
   });
 
   test("returns undefined for non-delivery paths", () => {
@@ -41,5 +44,6 @@ describe("channelForCallback", () => {
     expect(channelForCallback("/deliver/slack")).toBe("slack");
     expect(channelForCallback("/deliver/telegram")).toBe("telegram");
     expect(channelForCallback("/deliver/whatsapp")).toBe("whatsapp");
+    expect(channelForCallback("/deliver/discord")).toBe("discord");
   });
 });