@vellumai/assistant 0.11.2 → 0.11.3-staging.2

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

@@ -0,0 +1,204 @@
+import { describe, expect, test } from "bun:test";
+
+import { DISCORD_MAX_MESSAGE_LENGTH, renderDiscordMessages } from "./render.js";
+
+/** Count of fence lines in a chunk, which must be even for balanced markup. */
+function fenceLineCount(chunk: string): number {
+  return chunk.split("\n").filter((line) => /^\s*```/.test(line)).length;
+}
+
+/** The chunk text with fence bookkeeping lines removed. */
+function withoutFences(chunk: string): string {
+  return chunk
+    .split("\n")
+    .filter((line) => !/^\s*```/.test(line))
+    .join("\n");
+}
+
+describe("renderDiscordMessages", () => {
+  test("returns no chunks for blank input", () => {
+    expect(renderDiscordMessages("")).toEqual([]);
+    expect(renderDiscordMessages("   \n  ")).toEqual([]);
+  });
+
+  test("returns text under the cap unchanged, as a single chunk", () => {
+    expect(renderDiscordMessages("hello **world**")).toEqual([
+      "hello **world**",
+    ]);
+  });
+
+  test("passes markdown through without rewriting it", () => {
+    const markdown = "# Heading\n\n- one\n- two\n\n> quote\n\n`code` and *em*";
+    expect(renderDiscordMessages(markdown)).toEqual([markdown]);
+  });
+
+  test("splits at the real Discord cap, not just the injectable one", () => {
+    const text = "x".repeat(DISCORD_MAX_MESSAGE_LENGTH + 1);
+    const chunks = renderDiscordMessages(text);
+    expect(chunks.length).toBeGreaterThan(1);
+    for (const chunk of chunks) {
+      expect(chunk.length).toBeLessThanOrEqual(DISCORD_MAX_MESSAGE_LENGTH);
+    }
+  });
+
+  describe("with a small cap", () => {
+    const MAX = 40;
+
+    test("breaks on line boundaries and keeps every chunk within the cap", () => {
+      const lines = Array.from({ length: 12 }, (_, i) => `line number ${i}`);
+      const chunks = renderDiscordMessages(lines.join("\n"), MAX);
+
+      expect(chunks.length).toBeGreaterThan(1);
+      for (const chunk of chunks) {
+        expect(chunk.length).toBeLessThanOrEqual(MAX);
+      }
+      // Nothing lost, nothing duplicated.
+      expect(chunks.join("\n")).toBe(lines.join("\n"));
+    });
+
+    test("closes and reopens a code fence that spans a boundary", () => {
+      const body = Array.from({ length: 8 }, (_, i) => `const x${i} = ${i};`);
+      const text = ["```ts", ...body, "```"].join("\n");
+      const chunks = renderDiscordMessages(text, MAX);
+
+      expect(chunks.length).toBeGreaterThan(1);
+      for (const chunk of chunks) {
+        expect(chunk.length).toBeLessThanOrEqual(MAX);
+        // Balanced markup: an odd count means a chunk renders as broken code.
+        expect(fenceLineCount(chunk) % 2).toBe(0);
+      }
+      // Every continuation chunk reopens with the original info string, so the
+      // language highlighting survives the split.
+      for (const chunk of chunks.slice(1)) {
+        expect(chunk.startsWith("```ts")).toBe(true);
+      }
+      // The code itself is intact once the injected fences are stripped.
+      expect(chunks.map(withoutFences).join("\n")).toBe(body.join("\n"));
+    });
+
+    test("closes a four-backtick block with four backticks, not three", () => {
+      // A closing fence must be at least as long as its opener, so a block
+      // opened with ```` is not terminated by a ``` line: every chunk would
+      // render as one unterminated code block.
+      const body = Array.from({ length: 8 }, (_, i) => `line ${i}`);
+      const chunks = renderDiscordMessages(
+        ["````ts", ...body, "````"].join("\n"),
+        MAX,
+      );
+
+      expect(chunks.length).toBeGreaterThan(1);
+      for (const chunk of chunks) {
+        expect(chunk.length).toBeLessThanOrEqual(MAX);
+        const fences = chunk.split("\n").filter((l) => /^\s*`{3,}/.test(l));
+        expect(fences.length % 2).toBe(0);
+        // Both ends of every chunk use the opener's own delimiter.
+        for (const fence of fences) {
+          expect(fence.trimStart().startsWith("````")).toBe(true);
+        }
+      }
+    });
+
+    test("a three-backtick line is content inside a four-backtick block", () => {
+      // Opening with a longer run is exactly how a code block containing a
+      // fence is written, so the inner ``` must not close the outer block.
+      // The cap is small enough to force the splitter through its fence
+      // bookkeeping rather than returning the text whole.
+      const body = Array.from({ length: 6 }, (_, i) => `inner line ${i}`);
+      const chunks = renderDiscordMessages(
+        ["````md", "```ts", ...body, "```", "````"].join("\n"),
+        MAX,
+      );
+
+      expect(chunks.length).toBeGreaterThan(1);
+      // The outer block stays open throughout, so every continuation chunk
+      // reopens with ````. Treating the inner ``` as a close would end the
+      // block early and leave later chunks reopening with the wrong delimiter,
+      // or not at all.
+      for (const chunk of chunks.slice(1)) {
+        expect(chunk.startsWith("````md")).toBe(true);
+      }
+      for (const chunk of chunks) {
+        expect(chunk.length).toBeLessThanOrEqual(MAX);
+        expect(chunk.trimEnd().endsWith("````")).toBe(true);
+      }
+      // The inner fences survive as content rather than being consumed.
+      expect(chunks.join("\n")).toContain("```ts");
+    });
+
+    test("does not treat a fence inside an open block as a close", () => {
+      // A fence line carrying an info string cannot close a block, so this
+      // stays one code block rather than becoming two.
+      const text = ["```md", "```ts", "still inside", "```"].join("\n");
+      expect(renderDiscordMessages(text, 200)).toEqual([text]);
+    });
+
+    test("hard-splits a line longer than a whole chunk", () => {
+      const chunks = renderDiscordMessages("y".repeat(MAX * 3), MAX);
+      expect(chunks.length).toBeGreaterThan(2);
+      for (const chunk of chunks) {
+        expect(chunk.length).toBeLessThanOrEqual(MAX);
+      }
+      expect(chunks.join("")).toBe("y".repeat(MAX * 3));
+    });
+
+    test("hard-splits an over-long line inside a code block within the cap", () => {
+      // The reopened fence plus the closing fence eat into every continuation
+      // chunk's budget; a split that ignores them overflows the cap.
+      const text = ["```python", "z".repeat(MAX * 2), "```"].join("\n");
+      const chunks = renderDiscordMessages(text, MAX);
+
+      expect(chunks.length).toBeGreaterThan(1);
+      for (const chunk of chunks) {
+        expect(chunk.length).toBeLessThanOrEqual(MAX);
+        expect(fenceLineCount(chunk) % 2).toBe(0);
+      }
+      expect(chunks.map(withoutFences).join("")).toBe("z".repeat(MAX * 2));
+    });
+
+    test("charges the reopened fence against a code line that fits on its own", () => {
+      // Geometry chosen so each body line fits a chunk when only the closing
+      // fence is charged (30 + 4 <= 40) but not once the reopened "```python"
+      // is charged too (10 + 30 + 4 > 40). Budgeting only the close overflows
+      // the cap on every continuation chunk.
+      const body = ["a".repeat(30), "b".repeat(30)];
+      const chunks = renderDiscordMessages(
+        ["```python", ...body, "```"].join("\n"),
+        MAX,
+      );
+
+      for (const chunk of chunks) {
+        expect(chunk.length).toBeLessThanOrEqual(MAX);
+        expect(fenceLineCount(chunk) % 2).toBe(0);
+        // A chunk holding only a reopened fence pair renders as an empty code
+        // block, which is what an unbudgeted reopen produces here.
+        expect(withoutFences(chunk).trim().length).toBeGreaterThan(0);
+      }
+      // Each 30-char line exceeds what a continuation chunk can hold once the
+      // fence pair is charged, so it is cut mid-line and the newline between
+      // the two body lines does not survive. Character-level fidelity is the
+      // guarantee that does: nothing dropped, nothing duplicated.
+      expect(chunks.map(withoutFences).join("").replace(/\n/g, "")).toBe(
+        body.join(""),
+      );
+    });
+
+    test("never splits a surrogate pair", () => {
+      const chunks = renderDiscordMessages("😀".repeat(MAX), MAX);
+      for (const chunk of chunks) {
+        expect(chunk.length).toBeLessThanOrEqual(MAX);
+        // A broken pair leaves a lone surrogate at an edge.
+        expect(chunk).not.toMatch(/[\uD800-\uDBFF]$/);
+        expect(chunk).not.toMatch(/^[\uDC00-\uDFFF]/);
+      }
+      expect(chunks.join("")).toBe("😀".repeat(MAX));
+    });
+
+    test("emits no blank or fence-only chunks", () => {
+      const text = ["```ts", "a".repeat(MAX - 10), "```"].join("\n");
+      for (const chunk of renderDiscordMessages(text, MAX)) {
+        expect(chunk.trim().length).toBeGreaterThan(0);
+        expect(withoutFences(chunk).trim().length).toBeGreaterThan(0);
+      }
+    });
+  });
+});

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

@@ -0,0 +1,195 @@
+/**
+ * Discord message rendering: canonical reply markdown into sendable chunks.
+ *
+ * Discord renders a markdown dialect close to what the agent already writes
+ * (bold, italic, strikethrough, inline code, fenced code, blockquotes, lists,
+ * links, and headings h1 to h3), so the text passes through unmodified. The
+ * work here is splitting: `content` on Create Message is capped, and a reply
+ * over the cap is rejected outright rather than truncated.
+ *
+ * Splitting is fence-aware and line-aware because a naive slice breaks
+ * rendering, not just layout. Cutting inside a fenced code block leaves the
+ * first chunk with an unterminated fence and the second starting with a stray
+ * "```", so Discord renders both as garbage. Chunks therefore break on line
+ * boundaries where possible, and an open fence is closed at the end of one
+ * chunk and reopened (with its original info string) at the start of the next.
+ *
+ * https://docs.discord.com/developers/resources/message
+ */
+
+/**
+ * Discord's cap on the `content` field of a message. Chunks are built to fit
+ * inside this so the API never rejects a send for length.
+ */
+export const DISCORD_MAX_MESSAGE_LENGTH = 2000;
+
+/** A fence line: three or more backticks, optionally indented. */
+const FENCE_PATTERN = /^\s*(`{3,})/;
+
+/** A fence line carrying no info string, which can close an open block. */
+const BARE_FENCE_PATTERN = /^\s*`{3,}\s*$/;
+
+/**
+ * Length of a line's opening backtick run, or 0 when it is not a fence.
+ *
+ * The run length matters on both ends: a closing fence must be at least as
+ * long as the one it closes, so a block opened with four or more backticks is
+ * not terminated by a three-backtick line.
+ */
+function fenceRun(line: string): number {
+  return FENCE_PATTERN.exec(line)?.[1].length ?? 0;
+}
+
+/** The closing fence for an open block: its own delimiter, no info string. */
+function closeFor(openFence: string): string {
+  return "`".repeat(fenceRun(openFence));
+}
+
+/** Cost of appending a block's closing fence to a chunk: the line plus its newline. */
+function closeCostFor(openFence: string | undefined): number {
+  return openFence === undefined ? 0 : fenceRun(openFence) + 1;
+}
+
+/**
+ * The open-fence state after `line` is appended, given the state before it.
+ * `undefined` means no code block is open; otherwise it is the opening fence
+ * line verbatim, so a split can reopen the block with its original delimiter
+ * and info string.
+ */
+function fenceStateAfter(
+  line: string,
+  openFence: string | undefined,
+): string | undefined {
+  const run = fenceRun(line);
+  if (run === 0) {
+    return openFence;
+  }
+  if (openFence === undefined) {
+    return line;
+  }
+  // A fence closes the block only when it carries no info string and its run
+  // is at least as long as the opener. Anything else is content inside it,
+  // which is the whole point of opening with a longer run.
+  return BARE_FENCE_PATTERN.test(line) && run >= fenceRun(openFence)
+    ? undefined
+    : openFence;
+}
+
+/**
+ * Split a reply into Discord-sized chunks, preserving fenced code blocks
+ * across the boundaries.
+ *
+ * Returns an empty array for blank input so callers can skip the send
+ * entirely rather than posting an empty message, which Discord rejects.
+ */
+export function renderDiscordMessages(
+  text: string,
+  maxLength: number = DISCORD_MAX_MESSAGE_LENGTH,
+): string[] {
+  if (!text || text.trim().length === 0) {
+    return [];
+  }
+  if (text.length <= maxLength) {
+    return [text];
+  }
+
+  const chunks: string[] = [];
+  let current: string[] = [];
+  let currentLength = 0;
+  /** Fence state at the start of the line being placed. */
+  let openFence: string | undefined;
+
+  /** Close the chunk in progress, reopening an in-flight fence in the next. */
+  const flush = (fenceToReopen: string | undefined): void => {
+    if (current.length === 0) {
+      return;
+    }
+    if (fenceToReopen !== undefined) {
+      current.push(closeFor(fenceToReopen));
+    }
+    chunks.push(current.join("\n"));
+    current = [];
+    currentLength = 0;
+    if (fenceToReopen !== undefined) {
+      current.push(fenceToReopen);
+      currentLength = fenceToReopen.length;
+    }
+  };
+
+  /**
+   * Append one line. `reserve` is the room the closing fence will need once
+   * this line is in place, which is why the caller computes the fence state
+   * first: an opening fence must budget for its own close.
+   */
+  const push = (line: string, reserve: number): void => {
+    const separator = current.length === 0 ? 0 : 1;
+    if (currentLength + separator + line.length + reserve > maxLength) {
+      flush(openFence);
+    }
+    current.push(line);
+    currentLength += (current.length === 1 ? 0 : 1) + line.length;
+  };
+
+  for (const line of text.split("\n")) {
+    const nextFence = fenceStateAfter(line, openFence);
+    // Room the closing fence needs once this line is placed, which is why the
+    // fence state is computed first: an opening fence must budget for its own
+    // close.
+    const closeCost = closeCostFor(nextFence);
+    // Room the reopened fence takes at the head of a fresh chunk. Charged
+    // against the state *before* this line, because that is the fence a flush
+    // would carry over.
+    const reopenCost = openFence === undefined ? 0 : openFence.length + 1;
+
+    if (reopenCost + line.length + closeCost > maxLength) {
+      // The line cannot fit even alone in a fresh chunk, so it cannot break on
+      // a newline and is cut at the character level. The pieces are fragments
+      // of one logical line, so the fence state does not advance across them.
+      for (const piece of hardSplit(line, maxLength - reopenCost - closeCost)) {
+        push(piece, closeCost);
+      }
+      openFence = nextFence;
+      continue;
+    }
+
+    push(line, closeCost);
+    openFence = nextFence;
+  }
+
+  // A trailing chunk holding nothing but a reopened fence would render as an
+  // empty code block, so it is dropped rather than sent.
+  const onlyReopenedFence =
+    openFence !== undefined && current.length === 1 && current[0] === openFence;
+  if (current.length > 0 && !onlyReopenedFence) {
+    if (openFence !== undefined) {
+      current.push(closeFor(openFence));
+    }
+    chunks.push(current.join("\n"));
+  }
+
+  return chunks.filter((chunk) => chunk.trim().length > 0);
+}
+
+/**
+ * Cut an over-long line into pieces of at most `maxLength`, never splitting a
+ * surrogate pair (which would emit a lone half and render as a replacement
+ * character).
+ */
+function hardSplit(line: string, maxLength: number): string[] {
+  const safeMax = Math.max(1, maxLength);
+  const pieces: string[] = [];
+  let cursor = 0;
+  while (cursor < line.length) {
+    let end = Math.min(cursor + safeMax, line.length);
+    if (
+      end < line.length &&
+      line.charCodeAt(end - 1) >= 0xd800 &&
+      line.charCodeAt(end - 1) <= 0xdbff
+    ) {
+      end--;
+    }
+    pieces.push(line.slice(cursor, end));
+    cursor = end;
+  }
+  return pieces;
+}

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

@@ -0,0 +1,179 @@
+/**
+ * The Discord request shape, asserted against a stubbed fetch.
+ *
+ * `render.test.ts` covers how a reply is split; this covers what actually
+ * goes on the wire: the route, the auth header, the mention policy, chunk
+ * ordering, and the documented multipart upload form. Those are the parts a
+ * unit test can hold, and the parts whose breakage is silent (a wrong route
+ * 404s into a failed delivery, a missing `allowed_mentions` pings a server).
+ */
+
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+
+const BOT_TOKEN = "discord-bot-token";
+
+const realSecureKeys = await import("../../../security/secure-keys.js");
+mock.module("../../../security/secure-keys.js", () => ({
+  ...realSecureKeys,
+  getSecureKeyResultAsync: async () => ({
+    value: BOT_TOKEN,
+    unreachable: false,
+  }),
+}));
+
+mock.module("../../../persistence/attachments-store.js", () => ({
+  getAttachmentContent: (id: string) =>
+    id === "missing" ? null : Buffer.from("file-bytes"),
+}));
+
+mock.module("../../../util/logger.js", () => ({
+  getLogger: () => ({ debug() {}, info() {}, warn() {}, error() {} }),
+}));
+
+const { sendDiscordReply, sendDiscordAttachments } = await import("./send.js");
+
+const originalFetch = globalThis.fetch;
+
+interface Captured {
+  url: string;
+  method: string;
+  headers: Record<string, string>;
+  body: unknown;
+}
+
+let calls: Captured[] = [];
+
+function stubFetch(status = 200, payload: unknown = { id: "msg-1" }): void {
+  globalThis.fetch = (async (url: string | URL, init?: RequestInit) => {
+    const headers = Object.fromEntries(
+      new Headers(init?.headers ?? {}).entries(),
+    );
+    calls.push({
+      url: String(url),
+      method: init?.method ?? "GET",
+      headers,
+      body: init?.body,
+    });
+    return new Response(status === 204 ? null : JSON.stringify(payload), {
+      status,
+      headers: { "content-type": "application/json" },
+    });
+  }) as unknown as typeof fetch;
+}
+
+beforeEach(() => {
+  calls = [];
+  stubFetch();
+});
+
+afterEach(() => {
+  globalThis.fetch = originalFetch;
+});
+
+describe("sendDiscordReply", () => {
+  test("posts to the channel's messages route with bot auth", async () => {
+    await sendDiscordReply({ channelId: "C1" }, "hello");
+
+    expect(calls).toHaveLength(1);
+    expect(calls[0].url).toBe(
+      "https://discord.com/api/v10/channels/C1/messages",
+    );
+    expect(calls[0].method).toBe("POST");
+    // Discord rejects a bare token: the scheme prefix is required.
+    expect(calls[0].headers.authorization).toBe(`Bot ${BOT_TOKEN}`);
+  });
+
+  test("withholds everyone and role mentions", async () => {
+    // The agent composes this text and may echo mention markup from an
+    // untrusted inbound message, so it must never be able to ping a whole
+    // server. Losing this field is silent until it pings 5000 people.
+    await sendDiscordReply({ channelId: "C1" }, "@everyone hi <@&12345>");
+
+    const body = JSON.parse(calls[0].body as string);
+    expect(body.allowed_mentions).toEqual({ parse: ["users"] });
+    expect(body.allowed_mentions.parse).not.toContain("everyone");
+    expect(body.allowed_mentions.parse).not.toContain("roles");
+    // The text itself is passed through unaltered; the policy does the work.
+    expect(body.content).toBe("@everyone hi <@&12345>");
+  });
+
+  test("targets a thread by its own id, never the parent channel", async () => {
+    await sendDiscordReply({ channelId: "T9" }, "in thread");
+    expect(calls[0].url).toContain("/channels/T9/messages");
+  });
+
+  test("sends long replies as ordered chunks, each carrying the policy", async () => {
+    const long = Array.from({ length: 400 }, (_, i) => `line ${i}`).join("\n");
+    const result = await sendDiscordReply({ channelId: "C1" }, long);
+
+    expect(calls.length).toBeGreaterThan(1);
+    const contents = calls.map((c) => JSON.parse(c.body as string).content);
+    // Reassembles in send order, so the reply reads top to bottom.
+    expect(contents.join("\n")).toBe(long);
+    for (const call of calls) {
+      expect(JSON.parse(call.body as string).allowed_mentions).toEqual({
+        parse: ["users"],
+      });
+    }
+    expect(result.lastMessageId).toBe("msg-1");
+  });
+
+  test("sends nothing for blank text", async () => {
+    await sendDiscordReply({ channelId: "C1" }, "   ");
+    expect(calls).toHaveLength(0);
+  });
+});
+
+describe("sendDiscordAttachments", () => {
+  test("uploads with the documented multipart form", async () => {
+    const result = await sendDiscordAttachments({ channelId: "C1" }, [
+      { id: "a1", filename: "report.pdf", mimeType: "application/pdf" },
+    ] as never);
+
+    expect(result.allFailed).toBe(false);
+    expect(calls).toHaveLength(1);
+    expect(calls[0].url).toBe(
+      "https://discord.com/api/v10/channels/C1/messages",
+    );
+
+    const form = calls[0].body as FormData;
+    expect(form).toBeInstanceOf(FormData);
+    // Files ride as `files[n]`, with the JSON body moved to `payload_json`
+    // and each file declared in `attachments` keyed by the same n.
+    expect(form.get("files[0]")).toBeInstanceOf(Blob);
+    const payload = JSON.parse(form.get("payload_json") as string);
+    expect(payload.attachments).toEqual([{ id: 0, filename: "report.pdf" }]);
+    expect(payload.allowed_mentions).toEqual({ parse: ["users"] });
+
+    // fetch must derive the multipart boundary, so Content-Type stays unset.
+    expect(calls[0].headers["content-type"]).toBeUndefined();
+  });
+
+  test("reports a refused upload instead of claiming success", async () => {
+    stubFetch(413, { message: "Request entity too large" });
+
+    const result = await sendDiscordAttachments({ channelId: "C1" }, [
+      { id: "a1", filename: "huge.bin" },
+    ] as never);
+
+    expect(result.allFailed).toBe(true);
+    expect(result.failureCount).toBe(1);
+    // The user gets a notice naming the file, not silence.
+    const notice = calls
+      .filter((c) => typeof c.body === "string")
+      .map((c) => JSON.parse(c.body as string).content)
+      .join(" ");
+    expect(notice).toContain("huge.bin");
+    expect(notice).toContain("413");
+  });
+
+  test("does not upload an attachment whose content is gone", async () => {
+    const result = await sendDiscordAttachments({ channelId: "C1" }, [
+      { id: "missing", filename: "ghost.txt" },
+    ] as never);
+
+    expect(result.allFailed).toBe(true);
+    // Only the failure notice, never a zero-byte upload.
+    expect(calls.every((c) => typeof c.body === "string")).toBe(true);
+  });
+});