@vellumai/assistant 0.11.4 → 0.11.5-staging.2

package/src/messaging/providers/__tests__/transport-dispatch.test.ts

@@ -18,6 +18,9 @@ const slack = {
   sendSlackStreamOp: mock((..._args: unknown[]) =>
     Promise.resolve({ ok: true, ts: "stream-ts" }),
   ),
+  updateSlackMessage: mock((..._args: unknown[]) =>
+    Promise.resolve({ ts: "slack-ts" }),
+  ),
 };
 const telegram = {
   sendTelegramReply: mock((..._args: unknown[]) => Promise.resolve()),
@@ -57,8 +60,17 @@ mock.module("../../../util/logger.js", () => ({
   getLogger: () => ({ debug() {}, info() {}, warn() {}, error() {} }),
 }));
 
-const { deliverDirect, isDirectDelivery, getTransportForCallback } =
-  await import("../index.js");
+const {
+  deliverDirect,
+  editChannelMessage,
+  sendChannelReaction,
+  sendChannelStreamOp,
+  sendChannelTyping,
+  setChannelThreadStatus,
+  supportsChannelTyping,
+  isDirectDelivery,
+  getTransportForCallback,
+} = await import("../index.js");
 
 const BASE = "https://gateway.internal";
 
@@ -134,56 +146,70 @@ describe("Slack sub-operation selection", () => {
     expect(opts.threadTs).toBe("1700.9");
   });
 
-  test("reaction routes to sendSlackReaction, not the text path", async () => {
-    await deliverDirect(
-      `${BASE}/deliver/slack`,
-      payload({
-        reaction: {
-          action: "add",
-          name: "white_check_mark",
-          messageTs: "1700.5",
-        },
-      }),
-    );
+  test("sendChannelReaction reaches Slack without touching the text path", async () => {
+    await sendChannelReaction(`${BASE}/deliver/slack`, {
+      chatId: "C1",
+      messageId: "1700.5",
+      emoji: "white_check_mark",
+      action: "add",
+    });
+
     expect(slack.sendSlackReaction).toHaveBeenCalledTimes(1);
     expect(slack.sendSlackReply).not.toHaveBeenCalled();
   });
 
-  test("assistantThreadStatus routes to sendSlackAssistantThreadStatus", async () => {
-    await deliverDirect(
-      `${BASE}/deliver/slack`,
-      payload({
-        assistantThreadStatus: {
-          channel: "C1",
-          threadTs: "1700.5",
-          status: "is thinking",
-        },
-      }),
-    );
+  test("editChannelMessage updates in place instead of posting", async () => {
+    await editChannelMessage(`${BASE}/deliver/slack`, {
+      chatId: "C1",
+      messageId: "1700.5",
+      text: "revised",
+    });
+
+    expect(slack.updateSlackMessage).toHaveBeenCalledTimes(1);
+    // The distinction the split exists for: an edit never reaches the post
+    // path, so a failed edit cannot become a second visible message.
+    expect(slack.sendSlackReply).not.toHaveBeenCalled();
+  });
+
+  test("setChannelThreadStatus reaches Slack without touching the text path", async () => {
+    await setChannelThreadStatus(`${BASE}/deliver/slack`, {
+      chatId: "C1",
+      threadTs: "1700.5",
+      status: "is thinking",
+    });
+
     expect(slack.sendSlackAssistantThreadStatus).toHaveBeenCalledTimes(1);
     expect(slack.sendSlackReply).not.toHaveBeenCalled();
   });
 
-  test("a typing payload to Slack falls through to deliver (no typing capability)", async () => {
-    await deliverDirect(
-      `${BASE}/deliver/slack`,
-      payload({ chatAction: "typing", text: "hi" }),
-    );
-    expect(slack.sendSlackReply).toHaveBeenCalledTimes(1);
+  test("a channel with no status surface resolves quietly", async () => {
+    const result = await setChannelThreadStatus(`${BASE}/deliver/telegram`, {
+      chatId: "123",
+      threadTs: "1700.5",
+      status: "is thinking",
+    });
+
+    expect(result).toEqual({ ok: true });
+    expect(telegram.sendTelegramReply).not.toHaveBeenCalled();
   });
 
-  test("slackStream routes to sendSlackStreamOp ahead of the text path", async () => {
-    const result = await deliverDirect(
+  test("sendChannelTyping resolves quietly for a channel with no typing capability", async () => {
+    const result = await sendChannelTyping(`${BASE}/deliver/slack`, "C1");
+
+    expect(result).toEqual({ ok: true });
+    expect(slack.sendSlackReply).not.toHaveBeenCalled();
+  });
+
+  test("sendChannelStreamOp reaches Slack without touching the text path", async () => {
+    const result = await sendChannelStreamOp(
       `${BASE}/deliver/slack?threadTs=1700.5`,
-      payload({
-        text: "ignored while streaming",
-        slackStream: { action: "start", threadTs: "1700.5" },
-      }),
+      "C1",
+      { action: "start", threadTs: "1700.5", markdownText: "hi" },
     );
     expect(slack.sendSlackStreamOp).toHaveBeenCalledTimes(1);
     expect(slack.sendSlackStreamOp.mock.calls[0]).toEqual([
       "C1",
-      { action: "start", threadTs: "1700.5" },
+      { action: "start", threadTs: "1700.5", markdownText: "hi" },
     ]);
     expect(slack.sendSlackReply).not.toHaveBeenCalled();
     expect(result).toEqual({ ok: true, ts: "stream-ts" });
@@ -191,22 +217,49 @@ describe("Slack sub-operation selection", () => {
 });
 
 describe("capability gating across channels", () => {
-  test("a reaction payload to Telegram falls through to deliver (no sendReaction)", async () => {
-    await deliverDirect(
-      `${BASE}/deliver/telegram`,
-      payload({
-        text: "hi",
-        reaction: { action: "add", name: "x", messageTs: "1" },
+  test("a channel with no reaction capability resolves quietly", async () => {
+    // Slack is the only channel that implements it, because the only producer
+    // is Slack's own acknowledgement fallback. A channel without the method
+    // is not a failed delivery, so nothing is attempted and nothing throws.
+    const target = {
+      chatId: "C1",
+      messageId: "1",
+      emoji: "eyes",
+      action: "add",
+    } as const;
+    expect(
+      await sendChannelReaction(`${BASE}/deliver/telegram`, target),
+    ).toEqual({ ok: true });
+    expect(telegram.sendTelegramReply).not.toHaveBeenCalled();
+  });
+
+  test("a channel that cannot revise a sent message resolves quietly", async () => {
+    // Only Slack implements `edit` today. A channel without the method is not
+    // a failed delivery: nothing is attempted, nothing throws, and no fresh
+    // message is posted in place of the revision.
+    expect(
+      await editChannelMessage(`${BASE}/deliver/telegram`, {
+        chatId: "C1",
+        messageId: "1",
+        text: "revised",
       }),
-    );
-    expect(telegram.sendTelegramReply).toHaveBeenCalledTimes(1);
+    ).toEqual({ ok: true });
+    expect(telegram.sendTelegramReply).not.toHaveBeenCalled();
   });
 
-  test("typing to Telegram routes to its typing indicator", async () => {
-    await deliverDirect(
-      `${BASE}/deliver/telegram`,
-      payload({ chatAction: "typing" }),
-    );
+  test("the typing capability is read from the transport, not the channel name", () => {
+    // The heartbeat gate in background-dispatch asks this rather than testing
+    // `sourceChannel === "telegram"`, so a channel that implements the method
+    // starts showing an indicator without a caller being changed.
+    expect(supportsChannelTyping(`${BASE}/deliver/telegram`)).toBe(true);
+    expect(supportsChannelTyping(`${BASE}/deliver/discord`)).toBe(true);
+    expect(supportsChannelTyping(`${BASE}/deliver/slack`)).toBe(false);
+    expect(supportsChannelTyping(`${BASE}/deliver/whatsapp`)).toBe(false);
+  });
+
+  test("sendChannelTyping reaches Telegram's typing indicator", async () => {
+    await sendChannelTyping(`${BASE}/deliver/telegram`, "123");
+
     expect(telegram.sendTelegramTypingIndicator).toHaveBeenCalledTimes(1);
   });
 
@@ -244,26 +297,21 @@ describe("capability gating across channels", () => {
     });
   });
 
-  test("a typing payload to Discord falls through to deliver (no sendTyping)", async () => {
-    // Only the Telegram heartbeat produces `chatAction: "typing"`, and it is
-    // gated on sourceChannel === "telegram", so Discord can never receive one.
-    // The transport implements no sendTyping, so this falls through.
-    await deliverDirect(
-      `${BASE}/deliver/discord`,
-      payload({ chatAction: "typing", text: "hi" }),
-    );
-    expect(discord.sendDiscordReply).toHaveBeenCalledTimes(1);
+  test("sendChannelTyping reaches Discord's typing indicator", async () => {
+    await sendChannelTyping(`${BASE}/deliver/discord`, "999");
+
+    expect(discord.sendDiscordTypingIndicator).toHaveBeenCalledTimes(1);
   });
 
-  test("a Slack-only stream payload to Discord falls through to deliver", async () => {
-    await deliverDirect(
-      `${BASE}/deliver/discord`,
-      payload({
-        text: "hi",
-        slackStream: { action: "start", threadTs: "1700.5" },
-      }),
-    );
-    expect(discord.sendDiscordReply).toHaveBeenCalledTimes(1);
+  test("a channel that cannot stream resolves quietly, and posts nothing", async () => {
+    const result = await sendChannelStreamOp(`${BASE}/deliver/discord`, "999", {
+      action: "start",
+      threadTs: "1700.5",
+      markdownText: "hi",
+    });
+
+    expect(result).toEqual({ ok: true });
+    expect(discord.sendDiscordReply).not.toHaveBeenCalled();
   });
 });
 

package/src/messaging/providers/channel-transport.ts

@@ -1,6 +1,8 @@
+import type { KnownBlock } from "@slack/types";
 import type {
   ChannelDeliveryResult,
   ChannelReplyPayload,
+  SlackStreamOp,
 } from "@vellumai/gateway-client";
 
 import type { ChannelId } from "../../channels/types.js";
@@ -15,15 +17,52 @@ export interface CallbackContext {
   readonly params: Readonly<Record<string, string>>;
 }
 
+/** The message an emoji reaction lands on, and what to do there. */
+export interface ReactionTarget {
+  readonly chatId: string;
+  /** The target message, in the channel's own id space. */
+  readonly messageId: string;
+  readonly emoji: string;
+  readonly action: "add" | "remove";
+}
+
+/**
+ * A status surface update. `chatId` is the room, spelled the way every other
+ * method on this interface spells it.
+ */
+export interface ThreadStatus {
+  readonly chatId: string;
+  readonly threadTs: string;
+  readonly status: string;
+  /** Rotating hints shown under the status while it holds. */
+  readonly loadingMessages?: readonly string[];
+}
+
+/**
+ * An existing message to replace in place, and what to replace it with.
+ *
+ * `messageId` is the target in the channel's own id space, the same way
+ * `chatId` is. `blocks` and `useBlocks` are the rendering inputs the edit
+ * carries, so a replacement renders the way the original did rather than
+ * degrading to plain text.
+ */
+export interface EditTarget {
+  readonly chatId: string;
+  readonly messageId: string;
+  readonly text: string;
+  readonly blocks?: readonly KnownBlock[];
+  readonly useBlocks?: boolean;
+}
+
 /**
  * Direct outbound delivery for one channel, wrapping the channel's provider-API
  * send functions behind a uniform surface. Transports are registered statically
  * (delivery runs in non-daemon contexts) and dispatched by channel, resolved
  * from the gateway callback URL via `callback-routing.ts`.
  *
- * The dispatcher routes a payload to the optional sub-operation methods when the
- * matching payload field is set and the method exists; otherwise it calls
- * `deliver`. A transport only implements the sub-operations it supports.
+ * Each operation takes its own parameters and is reached through its own entry
+ * point; a transport implements only the operations its channel supports, so
+ * an absent method is an absent capability.
  */
 export interface ChannelTransport {
   /** Canonical source channel id, e.g. `"slack"`. */
@@ -35,27 +74,65 @@ export interface ChannelTransport {
     payload: ChannelReplyPayload,
   ): Promise<ChannelDeliveryResult>;
 
-  /** Send a typing indicator. Routed when `payload.chatAction === "typing"`. */
-  sendTyping?(
+  /**
+   * Replace a message the assistant already sent.
+   *
+   * Distinct from `deliver`, which always posts something new. A channel that
+   * cannot revise a sent message omits this, and a caller that needs the
+   * revision to be visible has to post instead of silently doing nothing.
+   *
+   * An implementation must not fall back to posting when the edit fails. The
+   * original would remain beside the replacement, which reads as the assistant
+   * answering twice.
+   */
+  edit?(
     ctx: CallbackContext,
-    payload: ChannelReplyPayload,
+    target: EditTarget,
   ): Promise<ChannelDeliveryResult>;
 
-  /** Add an emoji reaction. Routed when `payload.reaction` is set. */
-  sendReaction?(
+  /**
+   * Show that the assistant is working, in whatever form the channel has.
+   *
+   * Takes the place and nothing else, because that is all it needs. A channel
+   * without the affordance omits the method, so implementing it is the whole
+   * of declaring the capability.
+   */
+  typing?(ctx: CallbackContext, chatId: string): Promise<ChannelDeliveryResult>;
+
+  /**
+   * Add or remove one of the assistant's own emoji reactions on a message.
+   *
+   * `messageId` is the target's id in the channel's own space, the same way
+   * `chatId` is: Slack spells it as a timestamp, Discord and Telegram as ids.
+   * Nothing outside the channel reads it, so nothing outside needs a shared
+   * spelling for it.
+   */
+  react?(
     ctx: CallbackContext,
-    payload: ChannelReplyPayload,
+    target: ReactionTarget,
   ): Promise<ChannelDeliveryResult>;
 
-  /** Update an assistant-thread status surface. Routed when `payload.assistantThreadStatus` is set. */
+  /**
+   * Set or clear the channel's own "working on it" surface.
+   *
+   * Distinct from `typing`: an indicator a channel refreshes on a timer versus
+   * a status a channel holds until it is changed. Slack has both and uses this
+   * one; a channel with only the first implements only `typing`.
+   */
   setThreadStatus?(
     ctx: CallbackContext,
-    payload: ChannelReplyPayload,
+    status: ThreadStatus,
   ): Promise<ChannelDeliveryResult>;
 
-  /** Perform one streaming operation. Routed when `payload.slackStream` is set. */
+  /**
+   * Advance a streamed reply: open it, add to it, or close it.
+   *
+   * A channel that can only post a finished message omits this, and the
+   * caller falls back to delivering the reply whole.
+   */
   streamReply?(
     ctx: CallbackContext,
-    payload: ChannelReplyPayload,
+    chatId: string,
+    op: SlackStreamOp,
   ): Promise<ChannelDeliveryResult>;
 }

package/src/messaging/providers/discord/send.ts

@@ -210,3 +210,19 @@ export async function sendDiscordAttachments(
     totalCount: attachments.length,
   };
 }
+
+/**
+ * Show the Discord typing indicator in a channel.
+ *
+ * Discord expires it after about ten seconds, so a caller that wants it to
+ * persist re-sends on a timer rather than clearing it; there is no stop route.
+ */
+export async function sendDiscordTypingIndicator(
+  target: DiscordSendTarget,
+): Promise<void> {
+  await callDiscordApi(
+    "POST",
+    `/channels/${encodeURIComponent(target.channelId)}/typing`,
+    {},
+  );
+}

package/src/messaging/providers/discord/transport.ts

@@ -7,7 +7,11 @@ import type {
 } from "../channel-transport.js";
 import { openDiscordDmChannel } from "./api.js";
 import type { DiscordSendTarget } from "./send.js";
-import { sendDiscordAttachments, sendDiscordReply } from "./send.js";
+import {
+  sendDiscordAttachments,
+  sendDiscordReply,
+  sendDiscordTypingIndicator,
+} from "./send.js";
 
 const log = getLogger("discord-transport");
 
@@ -43,6 +47,12 @@ async function sendTarget(
 export const discordTransport: ChannelTransport = {
   channel: "discord",
 
+  async typing(ctx, chatId) {
+    await sendDiscordTypingIndicator(await sendTarget(ctx, chatId));
+    log.debug({ chatId }, "Discord typing indicator delivered (direct)");
+    return { ok: true };
+  },
+
   async deliver(ctx, payload) {
     const { chatId, text, attachments, approval } = payload;
     const target = await sendTarget(ctx, chatId);

package/src/messaging/providers/index.ts

@@ -11,12 +11,19 @@
 import type {
   ChannelDeliveryResult,
   ChannelReplyPayload,
+  SlackStreamOp,
 } from "@vellumai/gateway-client";
 
 import { a2aTransport } from "./a2a/transport.js";
 import type { DirectDeliveryChannel } from "./callback-routing.js";
 import { channelForCallback } from "./callback-routing.js";
-import type { CallbackContext, ChannelTransport } from "./channel-transport.js";
+import type {
+  CallbackContext,
+  ChannelTransport,
+  EditTarget,
+  ReactionTarget,
+  ThreadStatus,
+} from "./channel-transport.js";
 import { discordTransport } from "./discord/transport.js";
 import { slackTransport } from "./slack/transport.js";
 import { telegramTransport } from "./telegram-bot/transport.js";
@@ -45,6 +52,105 @@ export function getTransportForCallback(
   return channel ? TRANSPORTS[channel] : undefined;
 }
 
+/**
+ * Whether the channel this callback addresses can show a working indicator.
+ *
+ * Asks the transport rather than the channel id, so a channel that gains the
+ * method starts being asked without a caller being told about it.
+ */
+export function supportsChannelTyping(callbackUrl: string): boolean {
+  return getTransportForCallback(callbackUrl)?.typing !== undefined;
+}
+
+/**
+ * Show that the assistant is working on the channel this callback addresses.
+ *
+ * Resolves to nothing when the channel has no such affordance, which is the
+ * ordinary case rather than a failure: the indicator is decoration, and a
+ * channel that cannot show one is not degraded by its absence.
+ */
+export async function sendChannelTyping(
+  callbackUrl: string,
+  chatId: string,
+): Promise<ChannelDeliveryResult> {
+  const transport = getTransportForCallback(callbackUrl);
+  if (!transport?.typing) {
+    return { ok: true };
+  }
+  return transport.typing(callbackContext(callbackUrl), chatId);
+}
+
+/**
+ * Add or remove one of the assistant's own reactions on a message.
+ *
+ * Resolves to nothing when the channel has none, the same as typing: a
+ * reaction is an acknowledgement, and a channel that cannot show one is not a
+ * failed delivery.
+ */
+/**
+ * Replace a message the assistant already sent.
+ *
+ * Returns `ok` without acting when the channel cannot revise a sent message,
+ * matching the other capability entry points: an absent method is an absent
+ * capability, not an error.
+ */
+export async function editChannelMessage(
+  callbackUrl: string,
+  target: EditTarget,
+): Promise<ChannelDeliveryResult> {
+  const transport = getTransportForCallback(callbackUrl);
+  if (!transport?.edit) {
+    return { ok: true };
+  }
+  return transport.edit(callbackContext(callbackUrl), target);
+}
+
+export async function sendChannelReaction(
+  callbackUrl: string,
+  target: ReactionTarget,
+): Promise<ChannelDeliveryResult> {
+  const transport = getTransportForCallback(callbackUrl);
+  if (!transport?.react) {
+    return { ok: true };
+  }
+  return transport.react(callbackContext(callbackUrl), target);
+}
+
+/**
+ * Set or clear the channel's status surface.
+ *
+ * Resolves to nothing when the channel holds none, so a caller does not have
+ * to know which channels do.
+ */
+export async function setChannelThreadStatus(
+  callbackUrl: string,
+  status: ThreadStatus,
+): Promise<ChannelDeliveryResult> {
+  const transport = getTransportForCallback(callbackUrl);
+  if (!transport?.setThreadStatus) {
+    return { ok: true };
+  }
+  return transport.setThreadStatus(callbackContext(callbackUrl), status);
+}
+
+/**
+ * Advance a streamed reply on the channel this callback addresses.
+ *
+ * Resolves to nothing when the channel cannot stream, so a caller that wants a
+ * streamed reply learns it has to send the whole thing instead.
+ */
+export async function sendChannelStreamOp(
+  callbackUrl: string,
+  chatId: string,
+  op: SlackStreamOp,
+): Promise<ChannelDeliveryResult> {
+  const transport = getTransportForCallback(callbackUrl);
+  if (!transport?.streamReply) {
+    return { ok: true };
+  }
+  return transport.streamReply(callbackContext(callbackUrl), chatId, op);
+}
+
 function callbackContext(callbackUrl: string): CallbackContext {
   const params: Record<string, string> = {};
   try {
@@ -74,9 +180,8 @@ export function isDirectDelivery(callbackUrl: string): boolean {
  * Deliver a channel reply directly to the provider API, bypassing the gateway
  * HTTP proxy. Callers MUST check `isDirectDelivery()` first.
  *
- * Sub-operations (reaction, thread status, typing) route to the transport's
- * optional method when both the payload field and the method are present;
- * otherwise the reply is delivered as text / approval / attachments.
+ * Delivers the reply itself: text, approval card, attachments. Every other
+ * operation a transport supports is reached through its own entry point.
  */
 export async function deliverDirect(
   callbackUrl: string,
@@ -90,17 +195,5 @@ export async function deliverDirect(
   }
 
   const ctx = callbackContext(callbackUrl);
-  if (payload.slackStream && transport.streamReply) {
-    return transport.streamReply(ctx, payload);
-  }
-  if (payload.reaction && transport.sendReaction) {
-    return transport.sendReaction(ctx, payload);
-  }
-  if (payload.assistantThreadStatus && transport.setThreadStatus) {
-    return transport.setThreadStatus(ctx, payload);
-  }
-  if (payload.chatAction === "typing" && transport.sendTyping) {
-    return transport.sendTyping(ctx, payload);
-  }
   return transport.deliver(ctx, payload);
 }

package/src/messaging/providers/slack/message-metadata.ts

@@ -1,5 +1,7 @@
 import { z } from "zod";
 
+import type { ProviderMessageMetadata } from "../../provider-message-metadata.js";
+
 /**
  * Typed Slack message metadata stored flat in the `messages.metadata` column
  * alongside whatever other top-level keys the broader metadata envelope
@@ -288,6 +290,49 @@ export function readSlackMetadataFromMessageMetadata(
   return opts?.allowFlatLegacy ? readSlackMetadata(metadata) : null;
 }
 
+/**
+ * Present a Slack row's stored metadata as the channel-neutral shape.
+ *
+ * `channelTs` is the row's own provider id and `targetChannelTs` the id of the
+ * message a reaction was attached to. Both are Slack `ts` strings, which is a
+ * Slack detail of the id format, not of the fact.
+ *
+ * The rest of Slack's envelope (file markers, timezone labels, channel name)
+ * stays there and is read from there by the Slack transcript renderer, which
+ * is a provider renderer by design.
+ */
+export function slackMetadataAsProviderMetadata(
+  meta: SlackMessageMetadata,
+): ProviderMessageMetadata {
+  return {
+    source: "slack",
+    conversationExternalId: meta.channelId,
+    // A reaction row stores the reacted message's ts in `channelTs`, which is
+    // its target rather than an id of its own.
+    ...(meta.eventKind === "reaction" ? {} : { messageId: meta.channelTs }),
+    ...(meta.actorExternalUserId
+      ? { actorExternalId: meta.actorExternalUserId }
+      : {}),
+    ...(meta.threadTs ? { threadId: meta.threadTs } : {}),
+    ...(meta.displayName ? { displayName: meta.displayName } : {}),
+    eventKind: meta.eventKind,
+    ...(meta.reaction
+      ? {
+          reaction: {
+            targetMessageId: meta.reaction.targetChannelTs,
+            emoji: meta.reaction.emoji,
+            op: meta.reaction.op,
+            ...(meta.reaction.actorDisplayName
+              ? { actorDisplayName: meta.reaction.actorDisplayName }
+              : {}),
+          },
+        }
+      : {}),
+    ...(meta.editedAt !== undefined ? { editedAt: meta.editedAt } : {}),
+    ...(meta.deletedAt !== undefined ? { deletedAt: meta.deletedAt } : {}),
+  };
+}
+
 /**
  * Serialize `SlackMessageMetadata` to a JSON string suitable for a fresh
  * write to the `messages.metadata` column. Use `mergeSlackMetadata` when an

package/src/messaging/providers/slack/render-transcript.ts

@@ -6,8 +6,7 @@
  * `{role, content}[]` chronologically ordered with compact Slack tags so the
  * model can reason across sibling threads in one channel.
  *
- * The function is pure: no I/O, no implicit clock reads. Time is taken from
- * `opts.now` only when needed for relative formatting. Sort and tag rendering
+ * The function is pure: no I/O, no implicit clock reads. Sort and tag rendering
  * are deterministic.
  *
  * Consumers wire this into inbound history rendering and the compaction
@@ -63,8 +62,6 @@ export interface RenderableSlackMessage {
 }
 
 export interface RenderOptions {
-  /** Reserved for future relative-time rendering; currently unused. */
-  now?: Date;
   /** Cap rendered reactions per parent message; default 5. */
   maxReactionsPerMessage?: number;
 }