@copilotkit/channels-discord 0.0.2

package/dist/event-renderer.test.js

@@ -0,0 +1,160 @@
+import { describe, it, expect, vi } from "vitest";
+import { createRunRenderer } from "./event-renderer.js";
+function fakeChannel() {
+    const sent = [];
+    let n = 0;
+    return {
+        sendTyping: vi.fn(async () => { }),
+        send: vi.fn(async (payload) => {
+            const id = `m${++n}`;
+            const msg = {
+                id,
+                content: typeof payload === "string" ? payload : (payload.content ?? ""),
+                edit: vi.fn(async (p) => {
+                    msg.content = typeof p === "string" ? p : (p.content ?? msg.content);
+                }),
+            };
+            sent.push(msg);
+            return msg;
+        }),
+        _sent: sent,
+    };
+}
+describe("createRunRenderer", () => {
+    it("fires a typing indicator on run start", () => {
+        const channel = fakeChannel();
+        const r = createRunRenderer({ channel: channel });
+        r.subscriber.onRunStartedEvent?.({ event: {} });
+        expect(channel.sendTyping).toHaveBeenCalledTimes(1);
+        // Stop the heartbeat so the interval doesn't dangle past the test.
+        r.subscriber.onRunFinishedEvent?.({ event: {} });
+    });
+    it("keeps the typing indicator alive across a long tool call, then stops on finish", () => {
+        vi.useFakeTimers();
+        try {
+            const channel = fakeChannel();
+            const r = createRunRenderer({ channel: channel });
+            r.subscriber.onRunStartedEvent?.({ event: {} });
+            // Immediate ping on start.
+            expect(channel.sendTyping).toHaveBeenCalledTimes(1);
+            // Discord typing expires ~10 s; the heartbeat refreshes every 8 s so a
+            // 40 s tool call never goes dead.
+            vi.advanceTimersByTime(8000);
+            expect(channel.sendTyping).toHaveBeenCalledTimes(2);
+            vi.advanceTimersByTime(8000 * 4); // ~40 s total elapsed
+            expect(channel.sendTyping).toHaveBeenCalledTimes(6);
+            // Once the run finishes, the heartbeat stops — no lingering "typing".
+            r.subscriber.onRunFinishedEvent?.({ event: {} });
+            vi.advanceTimersByTime(8000 * 5);
+            expect(channel.sendTyping).toHaveBeenCalledTimes(6);
+        }
+        finally {
+            vi.useRealTimers();
+        }
+    });
+    it("streams text deltas into a single edited message", async () => {
+        const channel = fakeChannel();
+        const r = createRunRenderer({ channel: channel });
+        r.subscriber.onTextMessageStartEvent?.({
+            event: { messageId: "a" },
+        });
+        r.subscriber.onTextMessageContentEvent?.({
+            event: { messageId: "a", delta: "Hel" },
+        });
+        r.subscriber.onTextMessageContentEvent?.({
+            event: { messageId: "a", delta: "lo" },
+        });
+        await r.subscriber.onTextMessageEndEvent?.({
+            event: { messageId: "a" },
+        });
+        expect(channel.send).toHaveBeenCalledTimes(1);
+        expect(channel._sent[0].content).toContain("Hello");
+    });
+    it("routes each chunk's edits to its own Discord message", async () => {
+        // A reply longer than the 2000-char Discord limit is split by
+        // ChunkedMessageStream into multiple Discord messages. Each posted
+        // message must receive ONLY its own slice via `edit()` — a regression
+        // here (a single per-AG-UI-message handle) routes every edit to the
+        // last-posted message, freezing earlier chunks on their placeholder.
+        const channel = fakeChannel();
+        const r = createRunRenderer({ channel: channel });
+        // Two distinct, newline-delimited blocks. Total > 2000 so the chunker
+        // freezes a boundary at the newline near the limit, producing exactly
+        // two Discord messages.
+        const first = "A".repeat(1500);
+        const second = "B".repeat(600);
+        const full = `${first}\n${second}`;
+        r.subscriber.onTextMessageStartEvent?.({
+            event: { messageId: "a" },
+        });
+        r.subscriber.onTextMessageContentEvent?.({
+            event: { messageId: "a", delta: full },
+        });
+        await r.subscriber.onTextMessageEndEvent?.({
+            event: { messageId: "a" },
+        });
+        // Two Discord messages posted (one per chunk).
+        expect(channel.send).toHaveBeenCalledTimes(2);
+        const [msg1, msg2] = channel._sent;
+        // Concatenate every edit each message received. The discriminator is
+        // that NO edit for a given message may carry the *other* chunk's
+        // content. With the regression (a single per-AG-UI-message handle keyed
+        // by messageId), chunk 0's final flush is minted after chunk 1's
+        // placeholder, so it overwrites the shared handle and msg2 receives an
+        // "A"-bearing edit — exactly what this asserts against.
+        const editsOf = (m) => m.edit.mock.calls
+            .map(([p]) => (typeof p === "string" ? p : (p?.content ?? "")))
+            .join(" ");
+        const msg1Edits = editsOf(msg1);
+        const msg2Edits = editsOf(msg2);
+        // Both messages were actually edited (not left on their placeholder).
+        expect(msg1.edit).toHaveBeenCalled();
+        expect(msg2.edit).toHaveBeenCalled();
+        // Each message only ever sees its OWN chunk's content.
+        expect(msg1Edits).toContain("A");
+        expect(msg1Edits).not.toContain("B");
+        expect(msg2Edits).toContain("B");
+        expect(msg2Edits).not.toContain("A");
+    });
+    it("captures a tool call for the run loop", async () => {
+        const channel = fakeChannel();
+        const r = createRunRenderer({ channel: channel });
+        await r.subscriber.onToolCallEndEvent?.({
+            event: { toolCallId: "t1" },
+            toolCallName: "render_card",
+            toolCallArgs: { id: "x" },
+        });
+        expect(r.getCapturedToolCalls()).toEqual([
+            {
+                toolCallId: "t1",
+                toolCallName: "render_card",
+                toolCallArgs: { id: "x" },
+            },
+        ]);
+    });
+    it("captures an on_interrupt custom event", () => {
+        const channel = fakeChannel();
+        const r = createRunRenderer({ channel: channel });
+        r.subscriber.onCustomEvent?.({
+            event: { name: "on_interrupt", value: { q: 1 } },
+        });
+        expect(r.getPendingInterrupt()).toEqual({
+            eventName: "on_interrupt",
+            value: { q: 1 },
+        });
+    });
+    it("posts a visible warning when an agent run errors", async () => {
+        const channel = fakeChannel();
+        const r = createRunRenderer({ channel: channel });
+        await r.subscriber.onRunErrorEvent?.({ event: { message: "boom" } });
+        expect(channel.send).toHaveBeenCalledTimes(1);
+        expect(channel._sent[0].content).toContain("boom");
+    });
+    it("does not post an error notice when the run was self-aborted", async () => {
+        const channel = fakeChannel();
+        const r = createRunRenderer({ channel: channel });
+        await r.markInterrupted();
+        await r.subscriber.onRunErrorEvent?.({ event: { message: "boom" } });
+        expect(channel.send).not.toHaveBeenCalled();
+    });
+});

package/dist/index.d.ts

@@ -0,0 +1,24 @@
+export { discord, DiscordAdapter } from "./adapter.js";
+export type { DiscordAdapterOptions } from "./adapter.js";
+export { DiscordConversationStore } from "./conversation-store.js";
+export { attachDiscordListener } from "./discord-listener.js";
+export type { ListenerConfig, ClientLike, IncomingCommandRaw, } from "./discord-listener.js";
+export { createRunRenderer } from "./event-renderer.js";
+export type { ChannelLike } from "./event-renderer.js";
+export { decodeInteraction } from "./interaction.js";
+export { conversationKeyOf } from "./types.js";
+export type { ReplyTarget, IncomingTurn } from "./types.js";
+export { renderComponents, renderDiscordMessage, } from "./render/components-v2.js";
+export { DISCORD_LIMITS } from "./render/budget.js";
+export { discordMarkdown } from "./markdown.js";
+export { MessageStream } from "./message-stream.js";
+export type { MessageStreamConfig } from "./message-stream.js";
+export { ChunkedMessageStream } from "./chunked-message-stream.js";
+export type { ChunkedMessageStreamConfig } from "./chunked-message-stream.js";
+export { autoCloseOpenMarkdown } from "./auto-close-streaming.js";
+export { registerCommands, jsonSchemaToDiscordOptions } from "./commands.js";
+export { buildFileContentParts } from "./download-files.js";
+export type { DiscordAttachmentRef, AgentContentPart, FileDeliveryConfig, MediaDataSource, } from "./download-files.js";
+export { defaultDiscordContext, discordTaggingContext, discordFormattingContext, discordConversationModelContext, } from "./built-in-context.js";
+export { lookupDiscordUserTool, defaultDiscordTools, } from "./built-in-tools.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AACvD,YAAY,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAC;AAE1D,OAAO,EAAE,wBAAwB,EAAE,MAAM,yBAAyB,CAAC;AAEnE,OAAO,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AAC9D,YAAY,EACV,cAAc,EACd,UAAU,EACV,kBAAkB,GACnB,MAAM,uBAAuB,CAAC;AAE/B,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AACxD,YAAY,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAEvD,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAErD,OAAO,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAC/C,YAAY,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAE5D,OAAO,EACL,gBAAgB,EAChB,oBAAoB,GACrB,MAAM,2BAA2B,CAAC;AAEnC,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAEpD,OAAO,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAEhD,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,YAAY,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAE/D,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AACnE,YAAY,EAAE,0BAA0B,EAAE,MAAM,6BAA6B,CAAC;AAE9E,OAAO,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAC;AAElE,OAAO,EAAE,gBAAgB,EAAE,0BAA0B,EAAE,MAAM,eAAe,CAAC;AAE7E,OAAO,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAC;AAC5D,YAAY,EACV,oBAAoB,EACpB,gBAAgB,EAChB,kBAAkB,EAClB,eAAe,GAChB,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EACL,qBAAqB,EACrB,qBAAqB,EACrB,wBAAwB,EACxB,+BAA+B,GAChC,MAAM,uBAAuB,CAAC;AAE/B,OAAO,EACL,qBAAqB,EACrB,mBAAmB,GACpB,MAAM,qBAAqB,CAAC"}

package/dist/index.js

@@ -0,0 +1,17 @@
+// Public API for @copilotkit/channels-discord.
+export { discord, DiscordAdapter } from "./adapter.js";
+export { DiscordConversationStore } from "./conversation-store.js";
+export { attachDiscordListener } from "./discord-listener.js";
+export { createRunRenderer } from "./event-renderer.js";
+export { decodeInteraction } from "./interaction.js";
+export { conversationKeyOf } from "./types.js";
+export { renderComponents, renderDiscordMessage, } from "./render/components-v2.js";
+export { DISCORD_LIMITS } from "./render/budget.js";
+export { discordMarkdown } from "./markdown.js";
+export { MessageStream } from "./message-stream.js";
+export { ChunkedMessageStream } from "./chunked-message-stream.js";
+export { autoCloseOpenMarkdown } from "./auto-close-streaming.js";
+export { registerCommands, jsonSchemaToDiscordOptions } from "./commands.js";
+export { buildFileContentParts } from "./download-files.js";
+export { defaultDiscordContext, discordTaggingContext, discordFormattingContext, discordConversationModelContext, } from "./built-in-context.js";
+export { lookupDiscordUserTool, defaultDiscordTools, } from "./built-in-tools.js";

package/dist/interaction.d.ts

@@ -0,0 +1,11 @@
+import type { InteractionEvent, IncomingReaction, IncomingModalSubmit } from "@copilotkit/channels";
+/** Decode a discord.js component interaction into the engine's opaque InteractionEvent. */
+export declare function decodeInteraction(raw: unknown): InteractionEvent | undefined;
+/** Decode a discord.js `ModalSubmitInteraction` into an `IncomingModalSubmit`. */
+export declare function decodeModalSubmit(interaction: unknown): IncomingModalSubmit;
+/**
+ * Decode a discord.js `MessageReaction` + `User` pair into an `IncomingReaction`.
+ * Returns `undefined` when required fields (emoji token, channelId, messageId) are missing.
+ */
+export declare function decodeReaction(reaction: unknown, user: unknown, added: boolean): IncomingReaction | undefined;
+//# sourceMappingURL=interaction.d.ts.map

package/dist/interaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interaction.d.ts","sourceRoot":"","sources":["../src/interaction.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,gBAAgB,EAChB,gBAAgB,EAChB,mBAAmB,EACpB,MAAM,sBAAsB,CAAC;AAqB9B,2FAA2F;AAC3F,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,OAAO,GAAG,gBAAgB,GAAG,SAAS,CAkD5E;AA4DD,kFAAkF;AAClF,wBAAgB,iBAAiB,CAAC,WAAW,EAAE,OAAO,GAAG,mBAAmB,CAmB3E;AAMD;;;GAGG;AACH,wBAAgB,cAAc,CAC5B,QAAQ,EAAE,OAAO,EACjB,IAAI,EAAE,OAAO,EACb,KAAK,EAAE,OAAO,GACb,gBAAgB,GAAG,SAAS,CAsB9B"}

package/dist/interaction.js

@@ -0,0 +1,138 @@
+/** Decode a discord.js component interaction into the engine's opaque InteractionEvent. */
+export function decodeInteraction(raw) {
+    const i = raw;
+    if (typeof i?.isButton !== "function")
+        return undefined;
+    const isButton = i.isButton();
+    const isSelect = i.isStringSelectMenu?.() ?? false;
+    if (!isButton && !isSelect)
+        return undefined;
+    const customId = i.customId ?? "";
+    const channelId = i.channelId ?? "";
+    const user = toUser(i.user);
+    // A button custom_id may be a handler id ("ck:…"), a packed value
+    // ("v:<json>"), or BOTH ("ck:…;v:<json>") when a button carries an onClick AND
+    // a value (e.g. the HITL confirm gate). Split the combined form so the onClick
+    // still dispatches by the bare id AND awaitChoice receives the bound value.
+    // For a select, JSON-parse the chosen value so a non-string option value
+    // (number/boolean/object) round-trips to its original type — mirroring bot-slack.
+    let id = customId;
+    let value;
+    if (isSelect) {
+        // Discord sends `values: string[]` for both single and multi selects; the
+        // unambiguous signal is the component's value bounds (the renderer sets
+        // maxValues > 1 and minValues 0 for multi). Multi → a string[] of all chosen
+        // values; single → the one value (mirrors bot-slack).
+        const c = i.component;
+        const multi = (c?.maxValues ?? 1) > 1 || c?.minValues === 0;
+        value = multi
+            ? (i.values ?? []).map(parseSelectValue)
+            : parseSelectValue(i.values?.[0]);
+    }
+    else {
+        const sep = customId.startsWith("ck:") ? customId.indexOf(";v:") : -1;
+        if (sep !== -1) {
+            id = customId.slice(0, sep);
+            value = unpackValue(customId.slice(sep + 1));
+        }
+        else {
+            value = unpackValue(customId);
+        }
+    }
+    return {
+        id,
+        conversationKey: channelId,
+        replyTarget: { channelId, ...(i.guildId ? { guildId: i.guildId } : {}) },
+        value,
+        user,
+        messageRef: i.message ? { id: i.message.id, channelId } : undefined,
+        // Filled by the adapter from the pending-interaction registry; the bare
+        // decode has no live trigger to attach.
+        triggerId: undefined,
+    };
+}
+/** JSON-parse a chosen select value so non-string option values round-trip; else keep the raw string. */
+function parseSelectValue(raw) {
+    if (typeof raw !== "string")
+        return raw;
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return raw;
+    }
+}
+/** A `v:<json>` custom_id carries a small bound value; anything else has none. */
+function unpackValue(customId) {
+    if (!customId.startsWith("v:"))
+        return undefined;
+    try {
+        return JSON.parse(customId.slice(2));
+    }
+    catch {
+        return undefined;
+    }
+}
+function toUser(u) {
+    if (!u?.id)
+        return undefined;
+    return { id: u.id, name: u.globalName ?? u.username, handle: u.username };
+}
+/** custom emoji → "name:id"; unicode → the char. */
+function emojiToken(e) {
+    if (!e?.name)
+        return undefined;
+    return e.id ? `${e.name}:${e.id}` : e.name;
+}
+/** Decode a discord.js `ModalSubmitInteraction` into an `IncomingModalSubmit`. */
+export function decodeModalSubmit(interaction) {
+    const i = interaction;
+    const values = {};
+    for (const [key, comp] of i.fields?.fields ?? new Map()) {
+        values[comp?.customId ?? key] = comp?.value;
+    }
+    return {
+        callbackId: i.customId ?? "",
+        values,
+        user: i.user?.id
+            ? { id: i.user.id, name: i.user.globalName ?? i.user.username }
+            : undefined,
+        conversationKey: i.channelId,
+        replyTarget: i.channelId
+            ? { channelId: i.channelId, ...(i.guildId ? { guildId: i.guildId } : {}) }
+            : undefined,
+        platform: "discord",
+        raw: interaction,
+    };
+}
+// ---------------------------------------------------------------------------
+// Reaction decode
+// ---------------------------------------------------------------------------
+/**
+ * Decode a discord.js `MessageReaction` + `User` pair into an `IncomingReaction`.
+ * Returns `undefined` when required fields (emoji token, channelId, messageId) are missing.
+ */
+export function decodeReaction(reaction, user, added) {
+    const r = reaction;
+    const u = user;
+    const token = emojiToken(r.emoji);
+    const channelId = r.message?.channelId;
+    const messageId = r.message?.id;
+    if (!token || !channelId || !messageId)
+        return undefined;
+    return {
+        rawEmoji: token,
+        added,
+        user: u.id ? { id: u.id, name: u.globalName ?? u.username } : undefined,
+        conversationKey: channelId,
+        replyTarget: {
+            channelId,
+            ...(r.message?.guildId ? { guildId: r.message.guildId } : {}),
+        },
+        messageId,
+        // Update-capable ref (channelId + message id) so an onReaction handler can
+        // edit the reacted message in place via thread.update.
+        messageRef: { id: messageId, channelId },
+        raw: reaction,
+    };
+}

package/dist/interaction.test.d.ts

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

package/dist/interaction.test.d.ts.map

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

package/dist/interaction.test.js

@@ -0,0 +1,120 @@
+import { describe, it, expect } from "vitest";
+import { decodeInteraction } from "./interaction.js";
+const baseMsg = { id: "m1" };
+const channel = { id: "c1", guildId: "g1" };
+describe("decodeInteraction", () => {
+    it("decodes a button click into an opaque InteractionEvent", () => {
+        const evt = decodeInteraction({
+            isButton: () => true,
+            isStringSelectMenu: () => false,
+            customId: "ck:abc123",
+            message: baseMsg,
+            channelId: "c1",
+            guildId: "g1",
+            user: { id: "u1", username: "ann", globalName: "Ann" },
+        });
+        expect(evt).toMatchObject({
+            id: "ck:abc123",
+            conversationKey: "c1",
+            replyTarget: { channelId: "c1", guildId: "g1" },
+            user: { id: "u1", name: "Ann", handle: "ann" },
+            messageRef: { id: "m1", channelId: "c1" },
+        });
+    });
+    it("unpacks a value-only custom_id (v:<json>)", () => {
+        const evt = decodeInteraction({
+            isButton: () => true,
+            isStringSelectMenu: () => false,
+            customId: 'v:{"confirmed":true}',
+            message: baseMsg,
+            channelId: "c1",
+            user: { id: "u1" },
+        });
+        expect(evt?.value).toEqual({ confirmed: true });
+    });
+    it("splits a combined handler+value custom_id (ck:<id>;v:<json>)", () => {
+        // A button with BOTH an onClick and a value (the HITL confirm gate). The
+        // bare id must still dispatch the onClick, AND the value must reach the
+        // awaitChoice waiter — otherwise an approval is read as "declined".
+        const evt = decodeInteraction({
+            isButton: () => true,
+            isStringSelectMenu: () => false,
+            customId: 'ck:abc123;v:{"confirmed":true}',
+            message: baseMsg,
+            channelId: "c1",
+            user: { id: "u1" },
+        });
+        expect(evt?.id).toBe("ck:abc123");
+        expect(evt?.value).toEqual({ confirmed: true });
+    });
+    it("decodes a string-select with its chosen values", () => {
+        const evt = decodeInteraction({
+            isButton: () => false,
+            isStringSelectMenu: () => true,
+            customId: "ck:sel1",
+            values: ["opt-b"],
+            message: baseMsg,
+            channelId: "c1",
+            user: { id: "u1" },
+        });
+        expect(evt).toMatchObject({ id: "ck:sel1", value: "opt-b" });
+    });
+    it("JSON-parses a string-select value that round-trips (object)", () => {
+        const evt = decodeInteraction({
+            isButton: () => false,
+            isStringSelectMenu: () => true,
+            customId: "ck:sel2",
+            values: ['{"k":1}'],
+            message: baseMsg,
+            channelId: "c1",
+            user: { id: "u1" },
+        });
+        expect(evt?.value).toEqual({ k: 1 });
+    });
+    it("JSON-parses a string-select value that round-trips (number)", () => {
+        const evt = decodeInteraction({
+            isButton: () => false,
+            isStringSelectMenu: () => true,
+            customId: "ck:sel3",
+            values: ["42"],
+            message: baseMsg,
+            channelId: "c1",
+            user: { id: "u1" },
+        });
+        expect(evt?.value).toBe(42);
+    });
+    it("keeps a plain non-JSON string-select value as the raw string", () => {
+        const evt = decodeInteraction({
+            isButton: () => false,
+            isStringSelectMenu: () => true,
+            customId: "ck:sel4",
+            values: ["opt-a"],
+            message: baseMsg,
+            channelId: "c1",
+            user: { id: "u1" },
+        });
+        expect(evt?.value).toBe("opt-a");
+    });
+    it("decodes a multi-select (maxValues > 1) into a string[] of chosen values", () => {
+        const evt = decodeInteraction({
+            isButton: () => false,
+            isStringSelectMenu: () => true,
+            customId: "ck:ms",
+            component: { maxValues: 5 },
+            values: ["core", "infra"],
+            message: baseMsg,
+            channelId: "c1",
+            user: { id: "u1" },
+        });
+        expect(evt?.value).toEqual(["core", "infra"]);
+    });
+    it("returns undefined for a non-component interaction", () => {
+        expect(decodeInteraction({
+            isButton: () => false,
+            isStringSelectMenu: () => false,
+        })).toBeUndefined();
+    });
+    it("returns undefined (not throws) when isStringSelectMenu is absent", () => {
+        expect(decodeInteraction({ isButton: () => false })).toBeUndefined();
+    });
+});

package/dist/markdown.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Discord's markdown is close to GFM, so this is mostly identity. The single
+ * real gap is tables: Discord renders none, so a contiguous GFM pipe-table
+ * block is wrapped in a code fence (monospace keeps the columns aligned).
+ */
+export declare function discordMarkdown(text: string): string;
+//# sourceMappingURL=markdown.d.ts.map

package/dist/markdown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"markdown.d.ts","sourceRoot":"","sources":["../src/markdown.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAGpD"}

package/dist/markdown.js

@@ -0,0 +1,66 @@
+/**
+ * Discord's markdown is close to GFM, so this is mostly identity. The single
+ * real gap is tables: Discord renders none, so a contiguous GFM pipe-table
+ * block is wrapped in a code fence (monospace keeps the columns aligned).
+ */
+export function discordMarkdown(text) {
+    if (!text.includes("|"))
+        return text;
+    return wrapPipeTables(text);
+}
+/** A GFM table row: starts/ends with optional pipes and contains at least one `|`. */
+const TABLE_ROW = /^\s*\|?.*\|.*$/;
+/** The separator row under the header: cells of dashes/colons (with optional outer pipes). */
+const TABLE_SEP = /^\s*\|?\s*:?-+:?\s*(\|\s*:?-+:?\s*)*\|?\s*$/;
+/** A fence delimiter line: ``` or ~~~ optionally followed by a language tag. */
+const FENCE = /^\s*(`{3,}|~{3,})/;
+/** Count GFM cells in a row: split on unescaped pipes, drop empty leading/trailing cells. */
+function cellCount(line) {
+    // Split on pipes that are NOT escaped (`\|` is a literal pipe inside a cell,
+    // not a column separator). Negative lookbehind needs Node 18+ (supported).
+    const cells = line.trim().split(/(?<!\\)\|/);
+    // A leading/trailing pipe produces an empty edge cell — ignore those.
+    if (cells.length && cells[0].trim() === "")
+        cells.shift();
+    if (cells.length && cells[cells.length - 1].trim() === "")
+        cells.pop();
+    return cells.length;
+}
+function wrapPipeTables(text) {
+    const lines = text.split("\n");
+    const out = [];
+    let i = 0;
+    let inFence = false;
+    while (i < lines.length) {
+        // Track existing fenced blocks so a model-fenced table is not double-wrapped.
+        if (FENCE.test(lines[i])) {
+            inFence = !inFence;
+            out.push(lines[i]);
+            i += 1;
+            continue;
+        }
+        // A table is a header row, a separator row whose column count matches the
+        // header, then >=1 body rows. Only detect outside an existing fence so prose
+        // with stray `|` (one row, no matching separator) is left alone.
+        if (!inFence &&
+            i + 1 < lines.length &&
+            TABLE_ROW.test(lines[i]) &&
+            TABLE_SEP.test(lines[i + 1]) &&
+            cellCount(lines[i + 1]) === cellCount(lines[i])) {
+            const block = [lines[i], lines[i + 1]];
+            i += 2;
+            while (i < lines.length &&
+                !FENCE.test(lines[i]) &&
+                TABLE_ROW.test(lines[i]) &&
+                lines[i].includes("|")) {
+                block.push(lines[i]);
+                i += 1;
+            }
+            out.push("```", ...block, "```");
+            continue;
+        }
+        out.push(lines[i]);
+        i += 1;
+    }
+    return out.join("\n");
+}

package/dist/markdown.test.d.ts

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

package/dist/markdown.test.d.ts.map

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

package/dist/markdown.test.js

@@ -0,0 +1,47 @@
+// packages/channels-discord/src/markdown.test.ts
+import { describe, it, expect } from "vitest";
+import { discordMarkdown } from "./markdown.js";
+describe("discordMarkdown", () => {
+    it("passes ordinary markdown through unchanged", () => {
+        const md = "**bold** _italic_ `code`\n# Heading\n- a\n- b";
+        expect(discordMarkdown(md)).toBe(md);
+    });
+    it("wraps a GFM table in a code fence (Discord can't render tables)", () => {
+        const md = ["| A | B |", "| - | - |", "| 1 | 2 |"].join("\n");
+        const out = discordMarkdown(md);
+        expect(out).toContain("```");
+        expect(out).toContain("A");
+        expect(out).toContain("1");
+        // The original pipe-table syntax must be inside a fence, not left raw.
+        expect(out.startsWith("```")).toBe(true);
+    });
+    it("leaves prose containing a stray pipe alone (no false-positive fence)", () => {
+        const md = "Use the `a | b` operator.\nIt is a bitwise or.";
+        expect(discordMarkdown(md)).toBe(md);
+    });
+    it("does not fence a one-row pseudo-table without a matching separator", () => {
+        const md = "| just | one | row |\nsome following prose";
+        expect(discordMarkdown(md)).toBe(md);
+    });
+    it("does not wrap when the separator column count mismatches the header", () => {
+        // Header has 2 columns, separator has 3 — not a real GFM table.
+        const md = "| A | B |\n| - | - | - |\n| 1 | 2 |";
+        expect(discordMarkdown(md)).toBe(md);
+    });
+    it("detects and wraps a table whose cell contains an escaped pipe", () => {
+        // Header has two cells: "A \| B" (an escaped pipe inside one cell) and "C".
+        // A naive split on every `|` would count three cells and fail to match the
+        // two-column separator, leaving the table unwrapped.
+        const md = ["| A \\| B | C |", "| - | - |", "| 1 | 2 |"].join("\n");
+        const out = discordMarkdown(md);
+        expect(out.startsWith("```")).toBe(true);
+        expect((out.match(/```/g) ?? []).length).toBe(2);
+    });
+    it("does not double-fence a table already inside a model fence", () => {
+        const md = ["```", "| A | B |", "| - | - |", "| 1 | 2 |", "```"].join("\n");
+        const out = discordMarkdown(md);
+        // Exactly the opening + closing fence — no extra inner pair.
+        expect((out.match(/```/g) ?? []).length).toBe(2);
+        expect(out).toBe(md);
+    });
+});