@vellumai/assistant 0.11.5 → 0.11.6-staging.1

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

@@ -9,9 +9,7 @@ const slack = {
     Promise.resolve({ ts: "slack-ts" }),
   ),
   sendSlackReaction: mock((..._args: unknown[]) => Promise.resolve()),
-  sendSlackAssistantThreadStatus: mock((..._args: unknown[]) =>
-    Promise.resolve(),
-  ),
+  sendSlackAgentSessionStatus: mock((..._args: unknown[]) => Promise.resolve()),
   sendSlackAttachments: mock((..._args: unknown[]) =>
     Promise.resolve({ allFailed: false, failureCount: 0 }),
   ),
@@ -23,6 +21,7 @@ const slack = {
   ),
 };
 const telegram = {
+  editTelegramMessage: mock((..._args: unknown[]) => Promise.resolve()),
   sendTelegramReply: mock((..._args: unknown[]) => Promise.resolve()),
   sendTelegramRichReply: mock((..._args: unknown[]) => Promise.resolve()),
   sendTelegramTypingIndicator: mock((..._args: unknown[]) => Promise.resolve()),
@@ -46,6 +45,7 @@ const discord = {
   sendDiscordTypingIndicator: mock((..._args: unknown[]) =>
     Promise.resolve(true),
   ),
+  editDiscordMessage: mock((..._args: unknown[]) => Promise.resolve()),
   sendDiscordAttachments: mock((..._args: unknown[]) =>
     Promise.resolve({ allFailed: false, failureCount: 0, totalCount: 0 }),
   ),
@@ -63,11 +63,9 @@ mock.module("../../../util/logger.js", () => ({
 const {
   deliverDirect,
   editChannelMessage,
-  sendChannelReaction,
   sendChannelStreamOp,
-  sendChannelTyping,
-  setChannelThreadStatus,
-  supportsChannelTyping,
+  setChannelActivity,
+  supportsChannelActivity,
   isDirectDelivery,
   getTransportForCallback,
 } = await import("../index.js");
@@ -146,18 +144,6 @@ describe("Slack sub-operation selection", () => {
     expect(opts.threadTs).toBe("1700.9");
   });
 
-  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("editChannelMessage updates in place instead of posting", async () => {
     await editChannelMessage(`${BASE}/deliver/slack`, {
       chatId: "C1",
@@ -171,31 +157,22 @@ describe("Slack sub-operation selection", () => {
     expect(slack.sendSlackReply).not.toHaveBeenCalled();
   });
 
-  test("setChannelThreadStatus reaches Slack without touching the text path", async () => {
-    await setChannelThreadStatus(`${BASE}/deliver/slack`, {
+  test("setChannelActivity reaches Slack without touching the text path", async () => {
+    await setChannelActivity(`${BASE}/deliver/slack`, {
       chatId: "C1",
-      threadTs: "1700.5",
-      status: "is thinking",
+      phase: "thinking",
     });
 
-    expect(slack.sendSlackAssistantThreadStatus).toHaveBeenCalledTimes(1);
+    expect(slack.sendSlackAgentSessionStatus).toHaveBeenCalledTimes(1);
     expect(slack.sendSlackReply).not.toHaveBeenCalled();
   });
 
-  test("a channel with no status surface resolves quietly", async () => {
-    const result = await setChannelThreadStatus(`${BASE}/deliver/telegram`, {
+  test("a channel with no activity indicator resolves quietly", async () => {
+    const result = await setChannelActivity(`${BASE}/deliver/whatsapp`, {
       chatId: "123",
-      threadTs: "1700.5",
-      status: "is thinking",
+      phase: "thinking",
     });
 
-    expect(result).toEqual({ ok: true });
-    expect(telegram.sendTelegramReply).not.toHaveBeenCalled();
-  });
-
-  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();
   });
@@ -204,12 +181,22 @@ describe("Slack sub-operation selection", () => {
     const result = await sendChannelStreamOp(
       `${BASE}/deliver/slack?threadTs=1700.5`,
       "C1",
-      { action: "start", threadTs: "1700.5", markdownText: "hi" },
+      {
+        action: "start",
+        anchorMessageId: "1700.5",
+        text: "hi",
+        appended: "hi",
+      },
     );
     expect(slack.sendSlackStreamOp).toHaveBeenCalledTimes(1);
     expect(slack.sendSlackStreamOp.mock.calls[0]).toEqual([
       "C1",
-      { action: "start", threadTs: "1700.5", markdownText: "hi" },
+      {
+        action: "start",
+        anchorMessageId: "1700.5",
+        text: "hi",
+        appended: "hi",
+      },
     ]);
     expect(slack.sendSlackReply).not.toHaveBeenCalled();
     expect(result).toEqual({ ok: true, ts: "stream-ts" });
@@ -217,48 +204,115 @@ describe("Slack sub-operation selection", () => {
 });
 
 describe("capability gating across channels", () => {
-  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 = {
+  test("Slack renders a muted edit as its own context block", async () => {
+    await editChannelMessage(`${BASE}/deliver/slack`, {
       chatId: "C1",
-      messageId: "1",
-      emoji: "eyes",
-      action: "add",
-    } as const;
-    expect(
-      await sendChannelReaction(`${BASE}/deliver/telegram`, target),
-    ).toEqual({ ok: true });
+      messageId: "1700.5",
+      text: "This approval request has been resolved.",
+      emphasis: "muted",
+    });
+
+    // The producer asked for a settled message and named no markup. Slack
+    // decides that means a context block.
+    const [, , , options] = slack.updateSlackMessage.mock.calls[0]!;
+    expect((options as { blocks?: unknown[] }).blocks).toEqual([
+      {
+        type: "context",
+        elements: [
+          {
+            type: "mrkdwn",
+            text: "This approval request has been resolved.",
+          },
+        ],
+      },
+    ]);
+  });
+
+  test("an edit with no emphasis carries no channel markup", async () => {
+    await editChannelMessage(`${BASE}/deliver/slack`, {
+      chatId: "C1",
+      messageId: "1700.5",
+      text: "revised",
+    });
+
+    const [, , , options] = slack.updateSlackMessage.mock.calls[0]!;
+    expect((options as { blocks?: unknown[] }).blocks).toBeUndefined();
+  });
+
+  test("editChannelMessage now reaches Telegram, not only Slack", async () => {
+    // The capability gate is what let Telegram gain this: no caller changed,
+    // the transport grew the method.
+    await editChannelMessage(`${BASE}/deliver/telegram`, {
+      chatId: "123",
+      messageId: "456",
+      text: "revised",
+    });
+
+    expect(telegram.editTelegramMessage).toHaveBeenCalledTimes(1);
     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.
+    // WhatsApp has no `edit`. 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`, {
+      await editChannelMessage(`${BASE}/deliver/whatsapp`, {
         chatId: "C1",
         messageId: "1",
         text: "revised",
       }),
     ).toEqual({ ok: true });
-    expect(telegram.sendTelegramReply).not.toHaveBeenCalled();
+    expect(whatsapp.sendWhatsAppReply).not.toHaveBeenCalled();
+  });
+
+  test("Discord edits in place instead of posting", async () => {
+    await editChannelMessage(`${BASE}/deliver/discord`, {
+      chatId: "C1",
+      messageId: "M9",
+      text: "revised",
+    });
+
+    expect(discord.editDiscordMessage).toHaveBeenCalledTimes(1);
+    // Same distinction the Slack case asserts: an edit never reaches the post
+    // path, so a failed edit cannot become a second visible message.
+    expect(discord.sendDiscordReply).not.toHaveBeenCalled();
   });
 
-  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("Discord renders a muted edit as subtext", async () => {
+    await editChannelMessage(`${BASE}/deliver/discord`, {
+      chatId: "C1",
+      messageId: "M9",
+      text: "This approval request has been resolved.",
+      emphasis: "muted",
+    });
+
+    // `muted` is surface-agnostic and each channel picks its own token. Slack
+    // uses a context block; Discord's nearest equivalent is subtext, which it
+    // renders at the size and colour of a dismiss line.
+    expect(discord.editDiscordMessage.mock.calls[0][3]).toEqual({
+      emphasis: "muted",
+    });
+  });
+
+  test("the activity capability is read from the transport, not the channel name", () => {
+    // The gate in background-dispatch asks this rather than testing
+    // `sourceChannel === "slack"`, so a channel that implements the method
+    // starts showing an indicator without a caller being changed. All three
+    // answer the same question now, which is the point of the single method:
+    // Slack holds its indicator and the other two re-assert theirs, and a
+    // caller cannot tell the difference.
+    expect(supportsChannelActivity(`${BASE}/deliver/slack`)).toBe(true);
+    expect(supportsChannelActivity(`${BASE}/deliver/telegram`)).toBe(true);
+    expect(supportsChannelActivity(`${BASE}/deliver/discord`)).toBe(true);
+    expect(supportsChannelActivity(`${BASE}/deliver/whatsapp`)).toBe(false);
   });
 
-  test("sendChannelTyping reaches Telegram's typing indicator", async () => {
-    await sendChannelTyping(`${BASE}/deliver/telegram`, "123");
+  test("setChannelActivity reaches Telegram's typing indicator", async () => {
+    await setChannelActivity(`${BASE}/deliver/telegram`, {
+      chatId: "123",
+      phase: "thinking",
+    });
 
     expect(telegram.sendTelegramTypingIndicator).toHaveBeenCalledTimes(1);
   });
@@ -297,8 +351,11 @@ describe("capability gating across channels", () => {
     });
   });
 
-  test("sendChannelTyping reaches Discord's typing indicator", async () => {
-    await sendChannelTyping(`${BASE}/deliver/discord`, "999");
+  test("setChannelActivity reaches Discord's typing indicator", async () => {
+    await setChannelActivity(`${BASE}/deliver/discord`, {
+      chatId: "999",
+      phase: "thinking",
+    });
 
     expect(discord.sendDiscordTypingIndicator).toHaveBeenCalledTimes(1);
   });
@@ -306,8 +363,9 @@ describe("capability gating across channels", () => {
   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",
+      anchorMessageId: "1700.5",
+      text: "hi",
+      appended: "hi",
     });
 
     expect(result).toEqual({ ok: true });

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

@@ -1,10 +1,10 @@
-import type { KnownBlock } from "@slack/types";
 import type {
   ChannelDeliveryResult,
   ChannelReplyPayload,
-  SlackStreamOp,
+  StreamOp,
 } from "@vellumai/gateway-client";
 
+import type { AssistantActivityPhase } from "../../api/index.js";
 import type { ChannelId } from "../../channels/types.js";
 
 /**
@@ -17,32 +17,43 @@ export interface CallbackContext {
   readonly params: Readonly<Record<string, string>>;
 }
 
-/** The message an emoji reaction lands on, and what to do there. */
-export interface ReactionTarget {
+/**
+ * How busy the assistant is in one conversation, for the channel to show.
+ *
+ * `phase` is the daemon's own activity phase rather than a channel's word for
+ * it, so every channel is told the same lifecycle and decides how to render
+ * it. A channel whose indicator expires on its own re-sends while the busy
+ * phases last; a channel whose indicator holds sets it once and clears it on
+ * `idle`. Neither shape leaks into what the caller says.
+ */
+export interface ActivityTarget {
   readonly chatId: string;
-  /** The target message, in the channel's own id space. */
-  readonly messageId: string;
-  readonly emoji: string;
-  readonly action: "add" | "remove";
+  readonly phase: AssistantActivityPhase;
+  /**
+   * Who started the turn. Channels that attribute a session to a person read
+   * it when the session is created, and ignore it afterwards.
+   */
+  readonly initiatorUserId?: string;
 }
 
 /**
- * A status surface update. `chatId` is the room, spelled the way every other
- * method on this interface spells it.
+ * Whether a phase means a turn is actually running.
+ *
+ * A channel with a plain busy indicator shows it for these and nothing else.
+ * `awaiting_confirmation` is deliberately not one: an approval is waiting on a
+ * person, and a typing bubble there promises output that is not coming.
  */
-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[];
+export function isBusyActivityPhase(phase: AssistantActivityPhase): boolean {
+  return (
+    phase === "thinking" || phase === "streaming" || phase === "tool_running"
+  );
 }
 
 /**
  * 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
+ * `chatId` is. `renderRichly` and `emphasis` are the rendering inputs the edit
  * carries, so a replacement renders the way the original did rather than
  * degrading to plain text.
  */
@@ -50,8 +61,14 @@ export interface EditTarget {
   readonly chatId: string;
   readonly messageId: string;
   readonly text: string;
-  readonly blocks?: readonly KnownBlock[];
-  readonly useBlocks?: boolean;
+  readonly renderRichly?: boolean;
+  /**
+   * How prominent the replacement should read. Surface-agnostic, the way
+   * `ApprovalActionOption.emphasis` is: each channel translates it to its own
+   * token, and one with no equivalent renders plain text. `muted` marks a
+   * message as settled rather than current.
+   */
+  readonly emphasis?: "muted";
 }
 
 /**
@@ -91,48 +108,48 @@ export interface ChannelTransport {
   ): Promise<ChannelDeliveryResult>;
 
   /**
-   * 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.
+   * Show how busy the assistant is, in whatever form the channel has.
    *
-   * `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.
+   * One capability rather than one per indicator shape: a self-expiring typing
+   * bubble and a status that holds until cleared answer the same question, and
+   * splitting them by how the channel keeps them alive forces every caller to
+   * know which channel it is talking to. A channel without any such affordance
+   * omits the method, so implementing it is the whole of declaring it.
    */
-  react?(
+  setActivity?(
     ctx: CallbackContext,
-    target: ReactionTarget,
+    target: ActivityTarget,
   ): Promise<ChannelDeliveryResult>;
 
   /**
-   * Set or clear the channel's own "working on it" surface.
+   * How often a busy indicator must be re-asserted to stay visible, for a
+   * channel whose indicator expires on its own.
    *
-   * 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`.
+   * Omitted by a channel whose indicator holds until it is changed, which is
+   * how a caller knows to set it once rather than run a timer. Declaring the
+   * cadence here keeps the caller from having to know which channel it is.
    */
-  setThreadStatus?(
-    ctx: CallbackContext,
-    status: ThreadStatus,
-  ): Promise<ChannelDeliveryResult>;
+  readonly activityRefreshMs?: number;
 
   /**
-   * Advance a streamed reply: open it, add to it, or close it.
+   * Advance a reply that grows while the turn runs: open it, add to it, or end
+   * it.
+   *
+   * A channel with no primitive for this omits the method, and the caller
+   * sends the finished reply instead. Omitting it is the correct answer for a
+   * platform that offers nothing here rather than a gap to paper over: a
+   * channel is not made to simulate streaming by rewriting a sent message,
+   * which is both a worse experience and, on Telegram, discouraged by the
+   * platform that does offer one.
    *
-   * A channel that can only post a finished message omits this, and the
-   * caller falls back to delivering the reply whole.
+   * What the channel leaves behind when the stream ends is its own business.
+   * Slack finalizes the streamed message in place; Telegram's live draft
+   * expires and the reply is persisted by an ordinary send. `stop` carries the
+   * complete reply so either can be true.
    */
   streamReply?(
     ctx: CallbackContext,
     chatId: string,
-    op: SlackStreamOp,
+    op: StreamOp,
   ): Promise<ChannelDeliveryResult>;
 }

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

@@ -30,7 +30,8 @@ mock.module("../../../util/logger.js", () => ({
   getLogger: () => ({ debug() {}, info() {}, warn() {}, error() {} }),
 }));
 
-const { sendDiscordReply, sendDiscordAttachments } = await import("./send.js");
+const { sendDiscordReply, sendDiscordAttachments, editDiscordMessage } =
+  await import("./send.js");
 
 const originalFetch = globalThis.fetch;
 
@@ -177,3 +178,47 @@ describe("sendDiscordAttachments", () => {
     expect(calls.every((c) => typeof c.body === "string")).toBe(true);
   });
 });
+
+describe("editDiscordMessage", () => {
+  const bodyOf = (index = 0): Record<string, unknown> =>
+    JSON.parse(String(calls[index]?.body)) as Record<string, unknown>;
+
+  test("patches the message rather than posting a new one", async () => {
+    await editDiscordMessage({ channelId: "C1" }, "M9", "revised");
+
+    expect(calls).toHaveLength(1);
+    expect(calls[0]?.method).toBe("PATCH");
+    expect(calls[0]?.url).toContain("/channels/C1/messages/M9");
+    expect(bodyOf().content).toBe("revised");
+  });
+
+  test("marks every line of a muted edit, not just the first", async () => {
+    // Discord's subtext applies per line, so one marker would render the first
+    // line small and leave the rest at body size.
+    await editDiscordMessage({ channelId: "C1" }, "M9", "Resolved.\nBy Ada.", {
+      emphasis: "muted",
+    });
+
+    expect(bodyOf().content).toBe("-# Resolved.\n-# By Ada.");
+  });
+
+  test("leaves a blank line alone", async () => {
+    // A bare `-# ` renders an empty subtext line rather than a gap.
+    await editDiscordMessage({ channelId: "C1" }, "M9", "One.\n\nTwo.", {
+      emphasis: "muted",
+    });
+
+    expect(bodyOf().content).toBe("-# One.\n\n-# Two.");
+  });
+
+  test("a rejected edit throws rather than posting a replacement", async () => {
+    // The reason editing is its own capability: falling back to a post would
+    // leave the original standing beside a duplicate.
+    stubFetch(400, { message: "Invalid Form Body" });
+
+    await expect(
+      editDiscordMessage({ channelId: "C1" }, "M9", "revised"),
+    ).rejects.toThrow();
+    expect(calls.every((call) => call.method === "PATCH")).toBe(true);
+  });
+});

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

@@ -65,6 +65,57 @@ export interface DiscordSendResult {
   lastMessageId?: string;
 }
 
+/**
+ * Discord's rendering of a settled message.
+ *
+ * `-# ` is Discord's subtext markdown, which it describes as the same size and
+ * colour as the dismiss line under a bot message. It is the closest thing
+ * Discord has to Slack's context block, and it applies per line, so every line
+ * carries the marker rather than only the first.
+ *
+ * @see https://support.discord.com/hc/en-us/articles/210298617
+ */
+function mutedText(text: string): string {
+  return text
+    .split("\n")
+    .map((line) => (line.trim().length === 0 ? line : `-# ${line}`))
+    .join("\n");
+}
+
+/**
+ * Replace a message the assistant already sent.
+ *
+ * Never posts. A failed edit throws so the original stands alone rather than
+ * gaining a duplicate beside it, which is the whole reason editing is its own
+ * capability.
+ *
+ * Deliberately does not chunk. An edit addresses one message, and a
+ * replacement too long for one is a condition the caller has to know about
+ * rather than one this can paper over by dropping the tail. Discord rejects an
+ * over-length body and that rejection propagates.
+ *
+ * @see https://discord.com/developers/docs/resources/message#edit-message
+ */
+export async function editDiscordMessage(
+  target: DiscordSendTarget,
+  messageId: string,
+  text: string,
+  options?: { emphasis?: "muted" },
+): Promise<void> {
+  await callDiscordApi<DiscordMessage>(
+    "PATCH",
+    `${messagesRoute(target)}/${encodeURIComponent(messageId)}`,
+    {
+      content: options?.emphasis === "muted" ? mutedText(text) : text,
+      allowed_mentions: DISCORD_ALLOWED_MENTIONS,
+    },
+  );
+  log.debug(
+    { channelId: target.channelId, messageId },
+    "Discord message edited",
+  );
+}
+
 /**
  * Send a text reply, split across as many messages as Discord's content cap
  * requires. Chunks post in order so the reply reads top to bottom.

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

@@ -5,9 +5,11 @@ import type {
   CallbackContext,
   ChannelTransport,
 } from "../channel-transport.js";
+import { isBusyActivityPhase } from "../channel-transport.js";
 import { openDiscordDmChannel } from "./api.js";
 import type { DiscordSendTarget } from "./send.js";
 import {
+  editDiscordMessage,
   sendDiscordAttachments,
   sendDiscordReply,
   sendDiscordTypingIndicator,
@@ -47,9 +49,30 @@ 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)");
+  // Discord clears a typing indicator after ten seconds.
+  activityRefreshMs: 8_000,
+
+  async edit(ctx, target) {
+    await editDiscordMessage(
+      await sendTarget(ctx, target.chatId),
+      target.messageId,
+      target.text,
+      { ...(target.emphasis ? { emphasis: target.emphasis } : {}) },
+    );
+    return { ok: true };
+  },
+
+  async setActivity(ctx, target) {
+    // Discord's typing indicator expires by itself after ten seconds, so a
+    // phase that is not running needs no clearing call.
+    if (!isBusyActivityPhase(target.phase)) {
+      return { ok: true };
+    }
+    await sendDiscordTypingIndicator(await sendTarget(ctx, target.chatId));
+    log.debug(
+      { chatId: target.chatId, phase: target.phase },
+      "Discord typing indicator delivered (direct)",
+    );
     return { ok: true };
   },