@copilotkit/channels-slack 0.1.0

package/dist/__tests__/event-renderer.test.js

@@ -0,0 +1,521 @@
+import { describe, it, expect, vi } from "vitest";
+import { createRunRenderer } from "../event-renderer.js";
+/**
+ * Fake {@link SlackRenderTransport} — records every post / update call in
+ * order. This is exactly the seam the managed Connector Outbox will drive, so
+ * the renderer is verified Bolt-free (no `WebClient`).
+ */
+function makeFakeClient() {
+    const posts = [];
+    const updates = [];
+    let postedTsCounter = 0;
+    const transport = {
+        setStatus: vi.fn(async () => { }),
+        postMessage: vi.fn(async (args) => {
+            postedTsCounter++;
+            const ts = `${postedTsCounter}.000`;
+            posts.push({ ...args, ts });
+            return { ts };
+        }),
+        updateMessage: vi.fn(async (args) => {
+            updates.push(args);
+        }),
+    };
+    return { transport, posts, updates };
+}
+describe("createRunRenderer", () => {
+    it("accumulates deltas into the final Slack message (the ECHO regression)", async () => {
+        // Reproduces the live bug: AG-UI's `textMessageBuffer` is the buffer
+        // *before* the current delta — it lags by one — so a renderer that
+        // forwards `textMessageBuffer` straight through ends up posting "E"
+        // instead of "ECHO". The renderer must accumulate deltas on its own.
+        const fake = makeFakeClient();
+        const { subscriber: sub } = createRunRenderer({
+            transport: fake.transport,
+            target: { channel: "C1", threadTs: "100.0" },
+        });
+        const id = "msg-1";
+        await sub.onTextMessageStartEvent({
+            event: { messageId: id, role: "assistant" },
+        });
+        sub.onTextMessageContentEvent({
+            event: { messageId: id, delta: "E" },
+            textMessageBuffer: "",
+        });
+        sub.onTextMessageContentEvent({
+            event: { messageId: id, delta: "CHO" },
+            textMessageBuffer: "E",
+        });
+        await sub.onTextMessageEndEvent({ event: { messageId: id } });
+        // (a) Text streaming posts a placeholder then updates it; the LAST
+        // update must be the fully-accumulated text.
+        expect(fake.posts).toHaveLength(1);
+        expect(fake.posts[0]?.text).toBe("_thinking…_");
+        expect(fake.updates.length).toBeGreaterThan(0);
+        expect(fake.updates.at(-1)?.text).toBe("ECHO");
+    });
+    it("posts placeholder with thread_ts for thread replies, none for DMs (only on first content)", async () => {
+        const fake = makeFakeClient();
+        const { subscriber: dm } = createRunRenderer({
+            transport: fake.transport,
+            target: { channel: "D1" },
+        });
+        await dm.onTextMessageStartEvent({
+            event: { messageId: "m1", role: "assistant" },
+        });
+        // No content yet → no Slack post (per the D20 fix).
+        expect(fake.posts).toHaveLength(0);
+        // First content event triggers the placeholder.
+        dm.onTextMessageContentEvent({
+            event: { messageId: "m1", delta: "hi" },
+            textMessageBuffer: "",
+        });
+        await dm.onTextMessageEndEvent({ event: { messageId: "m1" } });
+        expect(fake.posts[0]?.thread_ts).toBeUndefined();
+        const { subscriber: thread } = createRunRenderer({
+            transport: fake.transport,
+            target: { channel: "C1", threadTs: "100.0" },
+        });
+        await thread.onTextMessageStartEvent({
+            event: { messageId: "m2", role: "assistant" },
+        });
+        thread.onTextMessageContentEvent({
+            event: { messageId: "m2", delta: "hi" },
+            textMessageBuffer: "",
+        });
+        await thread.onTextMessageEndEvent({
+            event: { messageId: "m2" },
+        });
+        expect(fake.posts[1]?.thread_ts).toBe("100.0");
+    });
+    it("D20: a TEXT_MESSAGE_START + END with NO content events produces no Slack message", async () => {
+        const fake = makeFakeClient();
+        const { subscriber: sub } = createRunRenderer({
+            transport: fake.transport,
+            target: { channel: "C1", threadTs: "100.0" },
+        });
+        await sub.onTextMessageStartEvent({
+            event: { messageId: "m1", role: "assistant" },
+        });
+        await sub.onTextMessageEndEvent({ event: { messageId: "m1" } });
+        expect(fake.posts).toHaveLength(0);
+        expect(fake.updates).toHaveLength(0);
+    });
+    it("captures EVERY tool-call-end (getCapturedToolCalls returns it)", async () => {
+        const fake = makeFakeClient();
+        const { subscriber: sub, getCapturedToolCalls } = createRunRenderer({
+            transport: fake.transport,
+            target: { channel: "C1", threadTs: "100.0" },
+            showToolStatus: false,
+        });
+        await sub.onToolCallStartEvent({
+            event: { toolCallId: "tc1", toolCallName: "search_flights" },
+        });
+        await sub.onToolCallEndEvent({
+            event: { toolCallId: "tc1" },
+            toolCallName: "search_flights",
+            toolCallArgs: { from: "SFO", to: "JFK" },
+        });
+        const captured = getCapturedToolCalls();
+        expect(captured).toHaveLength(1);
+        expect(captured[0]).toEqual({
+            toolCallId: "tc1",
+            toolCallName: "search_flights",
+            toolCallArgs: { from: "SFO", to: "JFK" },
+        });
+    });
+    it("captures partial args from onToolCallArgsEvent, finalised at END", async () => {
+        const fake = makeFakeClient();
+        const { subscriber: sub, getCapturedToolCalls } = createRunRenderer({
+            transport: fake.transport,
+            target: { channel: "C1", threadTs: "100.0" },
+            showToolStatus: false,
+        });
+        sub.onToolCallArgsEvent({
+            event: { toolCallId: "tc1" },
+            toolCallName: "manage_todos",
+            partialToolCallArgs: { title: "partial" },
+        });
+        await sub.onToolCallEndEvent({
+            event: { toolCallId: "tc1" },
+            toolCallName: "manage_todos",
+            toolCallArgs: { title: "final" },
+        });
+        const captured = getCapturedToolCalls();
+        expect(captured).toHaveLength(1);
+        expect(captured[0]?.toolCallArgs).toEqual({ title: "final" });
+    });
+    it("tool-call status: showToolStatus default (true) → START posts 🔧, END edits to ✅", async () => {
+        const fake = makeFakeClient();
+        const { subscriber: sub } = createRunRenderer({
+            transport: fake.transport,
+            target: { channel: "C1", threadTs: "100.0" },
+        });
+        await sub.onToolCallStartEvent({
+            event: { toolCallId: "tc1", toolCallName: "search_flights" },
+        });
+        expect(fake.posts).toHaveLength(1);
+        expect(fake.posts[0]?.text).toContain(":wrench:");
+        await sub.onToolCallEndEvent({
+            event: { toolCallId: "tc1" },
+            toolCallName: "search_flights",
+            toolCallArgs: {},
+        });
+        expect(fake.updates).toHaveLength(1);
+        expect(fake.updates[0]?.text).toContain(":white_check_mark:");
+    });
+    it("tool-call status: showToolStatus:false → no status posts but still captures", async () => {
+        const fake = makeFakeClient();
+        const { subscriber: sub, getCapturedToolCalls } = createRunRenderer({
+            transport: fake.transport,
+            target: { channel: "C1", threadTs: "100.0" },
+            showToolStatus: false,
+        });
+        await sub.onToolCallStartEvent({
+            event: { toolCallId: "tc1", toolCallName: "search_flights" },
+        });
+        await sub.onToolCallEndEvent({
+            event: { toolCallId: "tc1" },
+            toolCallName: "search_flights",
+            toolCallArgs: {},
+        });
+        expect(fake.posts).toHaveLength(0);
+        expect(fake.updates).toHaveLength(0);
+        expect(getCapturedToolCalls()).toHaveLength(1);
+    });
+    it("tool-call status: dedup by toolCallId — a repeated START (e.g. on graph resume) does not double-post", async () => {
+        const fake = makeFakeClient();
+        const { subscriber: sub } = createRunRenderer({
+            transport: fake.transport,
+            target: { channel: "C1", threadTs: "100.0" },
+            showToolStatus: true,
+        });
+        await sub.onToolCallStartEvent({
+            event: { toolCallId: "tc1", toolCallName: "schedule_meeting" },
+        });
+        await sub.onToolCallStartEvent({
+            event: { toolCallId: "tc1", toolCallName: "schedule_meeting" },
+        });
+        expect(fake.posts).toHaveLength(1);
+    });
+    it("interrupt: an on_interrupt custom event sets getPendingInterrupt", async () => {
+        const fake = makeFakeClient();
+        const { subscriber: sub, getPendingInterrupt, clearPendingInterrupt, } = createRunRenderer({
+            transport: fake.transport,
+            target: { channel: "C1", threadTs: "100.0" },
+        });
+        sub.onCustomEvent({
+            event: { name: "on_interrupt", value: { question: "Confirm?" } },
+        });
+        const pending = getPendingInterrupt();
+        expect(pending).toBeDefined();
+        expect(pending?.eventName).toBe("on_interrupt");
+        expect(pending?.value).toEqual({ question: "Confirm?" });
+        clearPendingInterrupt();
+        expect(getPendingInterrupt()).toBeUndefined();
+    });
+    it("interrupt: a JSON-string value is parsed", async () => {
+        const fake = makeFakeClient();
+        const { subscriber: sub, getPendingInterrupt } = createRunRenderer({
+            transport: fake.transport,
+            target: { channel: "C1", threadTs: "100.0" },
+        });
+        sub.onCustomEvent({
+            event: { name: "on_interrupt", value: JSON.stringify({ ok: true }) },
+        });
+        expect(getPendingInterrupt()?.value).toEqual({ ok: true });
+    });
+    it("interrupt: a non-matching custom event is ignored", async () => {
+        const fake = makeFakeClient();
+        const { subscriber: sub, getPendingInterrupt } = createRunRenderer({
+            transport: fake.transport,
+            target: { channel: "C1", threadTs: "100.0" },
+        });
+        sub.onCustomEvent({
+            event: { name: "some_other_event", value: { x: 1 } },
+        });
+        expect(getPendingInterrupt()).toBeUndefined();
+    });
+    it("mrkdwn: bold/italic/links/lists get translated before chat.update", async () => {
+        const fake = makeFakeClient();
+        const { subscriber: sub } = createRunRenderer({
+            transport: fake.transport,
+            target: { channel: "C1", threadTs: "100.0" },
+        });
+        await sub.onTextMessageStartEvent({
+            event: { messageId: "m1", role: "assistant" },
+        });
+        sub.onTextMessageContentEvent({
+            event: {
+                messageId: "m1",
+                delta: "**hi** [docs](https://x.com)\n- a\n- b",
+            },
+            textMessageBuffer: "",
+        });
+        await sub.onTextMessageEndEvent({ event: { messageId: "m1" } });
+        const last = fake.updates.at(-1)?.text ?? "";
+        expect(last).toContain("*hi*");
+        expect(last).toContain("<https://x.com|docs>");
+        expect(last).toContain("•  a");
+    });
+    it("posts a warning when RUN_ERROR fires", async () => {
+        const fake = makeFakeClient();
+        const { subscriber: sub } = createRunRenderer({
+            transport: fake.transport,
+            target: { channel: "C1", threadTs: "100.0" },
+        });
+        await sub.onRunErrorEvent({ event: { message: "boom" } });
+        expect(fake.posts).toHaveLength(1);
+        expect(fake.posts[0]?.text).toContain("boom");
+        expect(fake.posts[0]?.thread_ts).toBe("100.0");
+    });
+    it("markInterrupted: appends _(interrupted)_ to a partial reply and finalises", async () => {
+        const fake = makeFakeClient();
+        const { subscriber, markInterrupted } = createRunRenderer({
+            transport: fake.transport,
+            target: { channel: "C1", threadTs: "100.0" },
+        });
+        await subscriber.onTextMessageStartEvent({
+            event: { messageId: "m1", role: "assistant" },
+        });
+        subscriber.onTextMessageContentEvent({
+            event: { messageId: "m1", delta: "Once upon a time" },
+            textMessageBuffer: "",
+        });
+        await markInterrupted();
+        const last = fake.updates.at(-1)?.text ?? "";
+        expect(last).toContain("Once upon a time");
+        expect(last).toContain("_(interrupted)_");
+    });
+    it("markInterrupted: no partial reply yet → no Slack post created", async () => {
+        const fake = makeFakeClient();
+        const { subscriber, markInterrupted } = createRunRenderer({
+            transport: fake.transport,
+            target: { channel: "C1", threadTs: "100.0" },
+        });
+        await subscriber.onTextMessageStartEvent({
+            event: { messageId: "m1", role: "assistant" },
+        });
+        // No content events arrived yet — interrupted IMMEDIATELY.
+        await markInterrupted();
+        expect(fake.posts).toHaveLength(0);
+        expect(fake.updates).toHaveLength(0);
+    });
+    it("markInterrupted: a RUN_ERROR event that arrives AFTER abort is suppressed", async () => {
+        const fake = makeFakeClient();
+        const { subscriber, markInterrupted } = createRunRenderer({
+            transport: fake.transport,
+            target: { channel: "C1", threadTs: "100.0" },
+        });
+        await subscriber.onTextMessageStartEvent({
+            event: { messageId: "m1", role: "assistant" },
+        });
+        subscriber.onTextMessageContentEvent({
+            event: { messageId: "m1", delta: "partial" },
+            textMessageBuffer: "",
+        });
+        await markInterrupted();
+        // Now AG-UI fires the late RUN_ERROR.
+        await subscriber.onRunErrorEvent({
+            event: { message: "aborted" },
+        });
+        const warnings = fake.posts.filter((p) => p.text.includes(":warning:"));
+        expect(warnings).toHaveLength(0);
+    });
+    it("markInterrupted: ignores late content events after the interrupt", async () => {
+        const fake = makeFakeClient();
+        const { subscriber, markInterrupted } = createRunRenderer({
+            transport: fake.transport,
+            target: { channel: "C1", threadTs: "100.0" },
+        });
+        await subscriber.onTextMessageStartEvent({
+            event: { messageId: "m1", role: "assistant" },
+        });
+        subscriber.onTextMessageContentEvent({
+            event: { messageId: "m1", delta: "partial" },
+            textMessageBuffer: "",
+        });
+        await markInterrupted();
+        const postsBefore = fake.posts.length;
+        // Late event after interrupt — should be ignored.
+        subscriber.onTextMessageContentEvent({
+            event: { messageId: "m1", delta: " more text" },
+            textMessageBuffer: "partial",
+        });
+        expect(fake.posts.length).toBe(postsBefore);
+    });
+    it("does not bleed buffers between messages with different ids", async () => {
+        const fake = makeFakeClient();
+        const { subscriber: sub } = createRunRenderer({
+            transport: fake.transport,
+            target: { channel: "C1", threadTs: "100.0" },
+        });
+        await sub.onTextMessageStartEvent({
+            event: { messageId: "a", role: "assistant" },
+        });
+        await sub.onTextMessageStartEvent({
+            event: { messageId: "b", role: "assistant" },
+        });
+        sub.onTextMessageContentEvent({
+            event: { messageId: "a", delta: "AAA" },
+            textMessageBuffer: "",
+        });
+        sub.onTextMessageContentEvent({
+            event: { messageId: "b", delta: "BBB" },
+            textMessageBuffer: "",
+        });
+        await sub.onTextMessageEndEvent({ event: { messageId: "a" } });
+        await sub.onTextMessageEndEvent({ event: { messageId: "b" } });
+        const lastUpdateForFirstTs = fake.updates
+            .filter((u) => u.ts === "1.000")
+            .at(-1);
+        const lastUpdateForSecondTs = fake.updates
+            .filter((u) => u.ts === "2.000")
+            .at(-1);
+        expect(lastUpdateForFirstTs?.text).toBe("AAA");
+        expect(lastUpdateForSecondTs?.text).toBe("BBB");
+    });
+});
+describe("createRunRenderer — native status mode", () => {
+    function makePaneClient() {
+        const statuses = [];
+        const posts = [];
+        const updates = [];
+        let counter = 0;
+        const transport = {
+            setStatus: vi.fn(async (args) => {
+                statuses.push({
+                    status: args.status,
+                    loading_messages: args.loading_messages,
+                    thread_ts: args.thread_ts,
+                });
+            }),
+            postMessage: vi.fn(async (args) => {
+                counter++;
+                const ts = `${counter}.000`;
+                posts.push({ text: args.text, ts });
+                return { ts };
+            }),
+            updateMessage: vi.fn(async (args) => {
+                updates.push(args);
+            }),
+        };
+        return { transport, statuses, posts };
+    }
+    it("sets native status on run start instead of posting a placeholder", async () => {
+        const f = makePaneClient();
+        const { subscriber: sub } = createRunRenderer({
+            transport: f.transport,
+            target: { channel: "D1", threadTs: "100.0" },
+            status: {
+                threadTs: "100.0",
+                isPane: true,
+                config: { thinking: "is pondering…", loadingMessages: ["a"] },
+            },
+        });
+        await sub.onRunStartedEvent({});
+        expect(f.posts).toHaveLength(0);
+        expect(f.statuses[0]).toEqual({
+            status: "is pondering…",
+            loading_messages: ["a"],
+            thread_ts: "100.0",
+        });
+    });
+    it("surfaces tool calls as live status, not :wrench: rows", async () => {
+        const f = makePaneClient();
+        const { subscriber: sub } = createRunRenderer({
+            transport: f.transport,
+            target: { channel: "D1", threadTs: "100.0" },
+            status: { threadTs: "100.0", isPane: true, config: {} },
+        });
+        await sub.onToolCallStartEvent({
+            event: { toolCallId: "t1", toolCallName: "search" },
+        });
+        expect(f.posts).toHaveLength(0);
+        expect(f.statuses.at(-1)?.status).toBe("is using `search`…");
+    });
+    it("showToolStatus:false suppresses the pane's `is using` status", async () => {
+        const f = makePaneClient();
+        const { subscriber: sub } = createRunRenderer({
+            transport: f.transport,
+            target: { channel: "D1", threadTs: "100.0" },
+            status: { threadTs: "100.0", isPane: true, config: {} },
+            showToolStatus: false,
+        });
+        await sub.onToolCallStartEvent({
+            event: { toolCallId: "t1", toolCallName: "search" },
+        });
+        expect(f.posts).toHaveLength(0);
+        expect(f.statuses.some((s) => s.status.includes("is using"))).toBe(false);
+    });
+    it("clears the status once a reply is posted", async () => {
+        const f = makePaneClient();
+        const { subscriber: sub } = createRunRenderer({
+            transport: f.transport,
+            target: { channel: "D1", threadTs: "100.0" },
+            status: { threadTs: "100.0", isPane: true, config: {} },
+        });
+        await sub.onRunStartedEvent({});
+        await sub.onTextMessageStartEvent({
+            event: { messageId: "m", role: "assistant" },
+        });
+        sub.onTextMessageContentEvent({
+            event: { messageId: "m", delta: "hi" },
+            textMessageBuffer: "",
+        });
+        await sub.onTextMessageEndEvent({ event: { messageId: "m" } });
+        expect(f.statuses.some((s) => s.status === "")).toBe(true);
+    });
+    it("clears the status on run finish when nothing was posted", async () => {
+        const f = makePaneClient();
+        const { subscriber: sub } = createRunRenderer({
+            transport: f.transport,
+            target: { channel: "D1", threadTs: "100.0" },
+            status: { threadTs: "100.0", isPane: true, config: { thinking: "t" } },
+        });
+        await sub.onRunStartedEvent({});
+        await sub.onRunFinishedEvent({});
+        expect(f.statuses.at(-1)?.status).toBe("");
+    });
+    // ── Non-pane: a channel @-mention / thread (isPane:false) gets the native
+    // "is thinking…" status instead of the old :hourglass: placeholder, and tool
+    // progress flows to both :wrench: rows and the composer "is using…" status
+    // (setStatus drives any thread anchor now, not just panes). ──────────────────
+    it("non-pane thread: sets native status on run start (no :hourglass: placeholder)", async () => {
+        const f = makePaneClient();
+        const { subscriber: sub } = createRunRenderer({
+            transport: f.transport,
+            target: { channel: "C1", threadTs: "100.0" },
+            status: { threadTs: "100.0", isPane: false, config: {} },
+        });
+        await sub.onRunStartedEvent({});
+        expect(f.posts).toHaveLength(0);
+        expect(f.statuses[0]?.status).toBe("is thinking…");
+    });
+    it("non-pane thread: tool calls post :wrench: rows and set composer status", async () => {
+        const f = makePaneClient();
+        const { subscriber: sub } = createRunRenderer({
+            transport: f.transport,
+            target: { channel: "C1", threadTs: "100.0" },
+            status: { threadTs: "100.0", isPane: false, config: {} },
+        });
+        await sub.onToolCallStartEvent({
+            event: { toolCallId: "t1", toolCallName: "search" },
+        });
+        expect(f.posts.at(-1)?.text).toContain(":wrench:");
+        expect(f.statuses.some((s) => s.status.includes("is using"))).toBe(true);
+    });
+    it("uses the provided threadTs anchor (e.g. a DM's inbound ts) for setStatus", async () => {
+        const f = makePaneClient();
+        const { subscriber: sub } = createRunRenderer({
+            transport: f.transport,
+            // Flat DM: the channel target has no threadTs, but the adapter passes the
+            // inbound message ts as the status anchor.
+            target: { channel: "D1" },
+            status: { threadTs: "999.000", isPane: false, config: {} },
+        });
+        await sub.onRunStartedEvent({});
+        expect(f.statuses[0]?.status).toBe("is thinking…");
+        expect(f.statuses[0]?.thread_ts).toBe("999.000");
+    });
+});

package/dist/__tests__/markdown-to-mrkdwn.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=markdown-to-mrkdwn.test.d.ts.map

package/dist/__tests__/markdown-to-mrkdwn.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"markdown-to-mrkdwn.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/markdown-to-mrkdwn.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/markdown-to-mrkdwn.test.js

@@ -0,0 +1,80 @@
+import { describe, it, expect } from "vitest";
+import { markdownToMrkdwn } from "../markdown-to-mrkdwn.js";
+describe("markdownToMrkdwn", () => {
+    it("**bold** → *bold*", () => {
+        expect(markdownToMrkdwn("hello **world**!")).toBe("hello *world*!");
+    });
+    it("__bold__ also → *bold*", () => {
+        expect(markdownToMrkdwn("__strong__ text")).toBe("*strong* text");
+    });
+    it("*italic* → _italic_", () => {
+        expect(markdownToMrkdwn("here is *emphasised* text")).toBe("here is _emphasised_ text");
+    });
+    it("~~strike~~ → ~strike~", () => {
+        expect(markdownToMrkdwn("~~gone~~")).toBe("~gone~");
+    });
+    it("# heading → *heading*", () => {
+        expect(markdownToMrkdwn("# Title")).toBe("*Title*");
+        expect(markdownToMrkdwn("### Sub")).toBe("*Sub*");
+    });
+    it("[text](url) → <url|text>", () => {
+        expect(markdownToMrkdwn("see [docs](https://x.com/d)")).toBe("see <https://x.com/d|docs>");
+    });
+    it("bullet markers (- * +) → •", () => {
+        const input = "- one\n* two\n+ three";
+        const expected = "•  one\n•  two\n•  three";
+        expect(markdownToMrkdwn(input)).toBe(expected);
+    });
+    it("indented bullets keep their indent", () => {
+        expect(markdownToMrkdwn("  - nested")).toBe("  •  nested");
+    });
+    it("does NOT touch contents of fenced code blocks", () => {
+        const md = "```\n**not bold here**\n- not a bullet\n```";
+        // body unchanged because it's inside a fence
+        expect(markdownToMrkdwn(md)).toBe(md);
+    });
+    it("does NOT touch contents of inline backticks", () => {
+        expect(markdownToMrkdwn("use `**stars**` here")).toBe("use `**stars**` here");
+    });
+    it("wraps GFM tables in a code fence so they render in monospace", () => {
+        const input = "| a | b |\n|---|---|\n| 1 | 2 |\n";
+        const out = markdownToMrkdwn(input);
+        expect(out.startsWith("```")).toBe(true);
+        expect(out).toContain("| a | b |");
+        expect(out).toContain("| 1 | 2 |");
+        expect(out.trim().endsWith("```")).toBe(true);
+    });
+    it("aligns table columns so monospace reads cleanly (no pipe-soup)", () => {
+        const input = "| name | role |\n|---|---|\n| LangGraph | Framework. |\n| AG-UI | Protocol. |\n";
+        const out = markdownToMrkdwn(input);
+        // Drop the separator row (no visual value in monospace).
+        expect(out).not.toContain("|---|");
+        // Each rendered data row should have the SAME line length now that
+        // columns are padded.
+        const dataLines = out
+            .split("\n")
+            .filter((l) => l.startsWith("|") && l.endsWith("|"));
+        expect(dataLines.length).toBe(3); // header + 2 data
+        const lens = dataLines.map((l) => l.length);
+        expect(new Set(lens).size).toBe(1); // all the same length
+    });
+    it("aligned table preserves cell contents", () => {
+        const input = "| col1 | col2 |\n|---|---|\n| a | b |\n";
+        const out = markdownToMrkdwn(input);
+        expect(out).toContain("col1");
+        expect(out).toContain("col2");
+        expect(out).toContain(" a "); // padded but content preserved
+        expect(out).toContain(" b ");
+    });
+    it("translates a paragraph with mixed formatting", () => {
+        const input = "**Hello** — see [docs](https://x.com) and try:\n- *fast* mode\n- **safe** mode";
+        const out = markdownToMrkdwn(input);
+        expect(out).toBe("*Hello* — see <https://x.com|docs> and try:\n•  _fast_ mode\n•  *safe* mode");
+    });
+    it("is a no-op for plain text", () => {
+        expect(markdownToMrkdwn("just plain words 123")).toBe("just plain words 123");
+    });
+    it("is a no-op for the empty string", () => {
+        expect(markdownToMrkdwn("")).toBe("");
+    });
+});

package/dist/__tests__/message-stream.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=message-stream.test.d.ts.map

package/dist/__tests__/message-stream.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"message-stream.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/message-stream.test.ts"],"names":[],"mappings":""}