@copilotkit/channels-discord 0.0.2

package/dist/download-files.js

@@ -0,0 +1,145 @@
+/**
+ * Inbound file transport. Discord messages can carry attachments; this turns
+ * them into AG-UI multimodal message content the agent's model can read —
+ * images as binary data parts and plain text/CSV/JSON/etc. as decoded `text`
+ * parts — downloading each from its public CDN URL (no auth required).
+ *
+ * The AgentContentPart union is intentionally identical to bot-slack's so the
+ * agent sees the same multimodal input shape across both adapters.
+ */
+const DEFAULT_MAX_BYTES = 10_000_000; // 10 MiB
+const DEFAULT_MAX_TEXT_BYTES = 200_000; // ~200 KiB
+const DEFAULT_MAX_FILES = 5;
+/** File extensions that indicate decodable plain text even when MIME is absent. */
+const TEXT_EXT_RE = /\.(txt|csv|json|md|log|tsv|ya?ml)$/i;
+function isTextMime(mime) {
+    return (mime.startsWith("text/") ||
+        mime === "application/json" ||
+        mime === "application/csv" ||
+        mime === "application/xml" ||
+        mime === "application/x-ndjson" ||
+        mime === "application/yaml");
+}
+function mediaPartType(mime) {
+    if (mime.startsWith("image/"))
+        return "image";
+    if (mime.startsWith("audio/"))
+        return "audio";
+    if (mime.startsWith("video/"))
+        return "video";
+    if (mime === "application/pdf")
+        return "document";
+    return null;
+}
+/**
+ * Download Discord message attachments and convert them to AG-UI content parts.
+ *
+ * Files whose reported size exceeds `maxBytes` are skipped WITHOUT fetching;
+ * the actual downloaded byte length is re-checked against the same cap after
+ * fetching. Images map to an image part; text/* MIME types and text-named
+ * files (.txt, .csv, .json, .md, .log, .tsv, .yaml) — including ones reported
+ * with a generic binary MIME like application/octet-stream — map to a text
+ * part (truncated to `maxTextBytes`); other binary content is skipped with a
+ * short text note explaining why (bot-slack parity), so the model knows a file
+ * was dropped.
+ *
+ * At most `maxFiles` attachments (default 5) are processed; any beyond that cap
+ * are ignored without fetching, bounding the multimodal payload a single
+ * message can inject.
+ */
+export async function buildFileContentParts(attachments, cfg = {}) {
+    const fetchImpl = cfg.fetchImpl ?? fetch;
+    const maxBytes = cfg.maxBytes ?? DEFAULT_MAX_BYTES;
+    const maxTextBytes = cfg.maxTextBytes ?? DEFAULT_MAX_TEXT_BYTES;
+    const maxFiles = cfg.maxFiles ?? DEFAULT_MAX_FILES;
+    const parts = [];
+    // Cap the number of attachments processed per message before any fetching,
+    // bounding the multimodal payload / token budget (bot-slack parity).
+    for (const att of attachments.slice(0, maxFiles)) {
+        // Gate on the reported size — skip (without fetching) if it exceeds the cap.
+        // Surface the skip as a note so the model knows a file was dropped and why
+        // (bot-slack parity).
+        if (att.size > maxBytes) {
+            parts.push({
+                type: "text",
+                text: `[attachment "${att.name}" skipped: ~${Math.round(att.size / 1e6)} MB exceeds the ${Math.round(maxBytes / 1e6)} MB limit]`,
+            });
+            continue;
+        }
+        const mime = (att.contentType ?? "").toLowerCase().split(";")[0].trim();
+        const media = mediaPartType(mime);
+        const textMime = isTextMime(mime);
+        // Treat a recognized text extension as text whenever the MIME isn't a
+        // medium we pass through and isn't itself a text MIME — this also covers
+        // generic/unrecognized binary types (e.g. application/octet-stream) that
+        // Discord sometimes reports for .csv/.json/etc. uploads.
+        const textName = !media && !textMime && TEXT_EXT_RE.test(att.name);
+        // Skip binary types we don't represent — surface as a note.
+        if (!media && !textMime && !textName) {
+            parts.push({
+                type: "text",
+                text: `[attachment "${att.name}" skipped: unsupported type ${mime || "unknown"}]`,
+            });
+            continue;
+        }
+        let res;
+        try {
+            res = await fetchImpl(att.url);
+        }
+        catch {
+            parts.push({
+                type: "text",
+                text: `[attachment "${att.name}" skipped: download failed]`,
+            });
+            continue;
+        }
+        if (!res.ok) {
+            parts.push({
+                type: "text",
+                text: `[attachment "${att.name}" skipped: download failed]`,
+            });
+            continue;
+        }
+        const bytes = new Uint8Array(await res.arrayBuffer());
+        // Double-check the actual downloaded size — the reported `att.size` can
+        // lie (or be absent), so re-gate on the real byte length.
+        if (bytes.length > maxBytes) {
+            parts.push({
+                type: "text",
+                text: `[attachment "${att.name}" skipped: ~${Math.round(bytes.length / 1e6)} MB exceeds the ${Math.round(maxBytes / 1e6)} MB limit]`,
+            });
+            continue;
+        }
+        if (media) {
+            // Binary media part — base64-encoded, exact same shape as bot-slack.
+            const effectiveMime = mime || `application/octet-stream`;
+            parts.push({
+                type: media,
+                source: {
+                    type: "data",
+                    value: Buffer.from(bytes).toString("base64"),
+                    mimeType: effectiveMime,
+                },
+            });
+        }
+        else {
+            // Text content — truncate the BYTES then decode (slicing the decoded
+            // string by character index would corrupt multi-byte UTF-8 and wouldn't
+            // actually bound the byte length). Append a note when truncated.
+            let buf = bytes;
+            let truncated = false;
+            if (buf.length > maxTextBytes) {
+                buf = buf.subarray(0, maxTextBytes);
+                truncated = true;
+            }
+            const text = new TextDecoder("utf-8").decode(buf);
+            parts.push({
+                type: "text",
+                text: `Attached file "${att.name}" (${mime || "text"}${truncated ? ", truncated" : ""}):\n` +
+                    text +
+                    (truncated ? "\n…(truncated)" : ""),
+            });
+        }
+    }
+    return parts;
+}

package/dist/download-files.test.d.ts

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

package/dist/download-files.test.d.ts.map

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

package/dist/download-files.test.js

@@ -0,0 +1,181 @@
+import { describe, it, expect, vi } from "vitest";
+import { buildFileContentParts } from "./download-files.js";
+describe("buildFileContentParts", () => {
+    it("turns an image attachment into an image content part", async () => {
+        const fetchImpl = vi.fn(async () => ({
+            ok: true,
+            arrayBuffer: async () => new Uint8Array([1, 2, 3]).buffer,
+        }));
+        const parts = await buildFileContentParts([
+            {
+                url: "https://cdn/x.png",
+                name: "x.png",
+                contentType: "image/png",
+                size: 3,
+            },
+        ], { fetchImpl });
+        expect(parts[0]).toMatchObject({ type: "image" });
+    });
+    it("decodes a text/csv attachment into a text content part", async () => {
+        const csv = "a,b\n1,2";
+        const fetchImpl = vi.fn(async () => ({
+            ok: true,
+            arrayBuffer: async () => new TextEncoder().encode(csv).buffer,
+        }));
+        const parts = await buildFileContentParts([
+            {
+                url: "https://cdn/x.csv",
+                name: "x.csv",
+                contentType: "text/csv",
+                size: csv.length,
+            },
+        ], { fetchImpl });
+        expect(parts[0]).toMatchObject({ type: "text" });
+        expect(JSON.stringify(parts[0])).toContain("a,b");
+    });
+    it("skips a file over the size cap without fetching (notes the skip)", async () => {
+        const fetchImpl = vi.fn();
+        const parts = await buildFileContentParts([
+            {
+                url: "https://cdn/big.bin",
+                name: "big.bin",
+                contentType: "application/octet-stream",
+                size: 99_000_000,
+            },
+        ], { fetchImpl, maxBytes: 10_000_000 });
+        // The file is gated pre-fetch but surfaced to the model as a skip note.
+        expect(parts).toHaveLength(1);
+        const note = parts[0];
+        expect(note.type).toBe("text");
+        expect(note.text).toContain("skipped");
+        expect(note.text).toContain("big.bin");
+        expect(fetchImpl).not.toHaveBeenCalled();
+    });
+    it("skips a file whose downloaded body exceeds the cap (reported size lied)", async () => {
+        // Reported size is under the cap, so it gets fetched — but the actual body
+        // is larger than maxBytes and must be dropped post-fetch.
+        const big = new Uint8Array(100);
+        const fetchImpl = vi.fn(async () => ({
+            ok: true,
+            arrayBuffer: async () => big.buffer,
+        }));
+        const parts = await buildFileContentParts([
+            {
+                url: "https://cdn/x.png",
+                name: "x.png",
+                contentType: "image/png",
+                size: 3,
+            },
+        ], { fetchImpl, maxBytes: 10 });
+        expect(fetchImpl).toHaveBeenCalledOnce();
+        // Dropped post-fetch but surfaced to the model as a skip note.
+        expect(parts).toHaveLength(1);
+        const note = parts[0];
+        expect(note.type).toBe("text");
+        expect(note.text).toContain("skipped");
+        expect(note.text).toContain("x.png");
+    });
+    it("truncates a text body larger than maxTextBytes", async () => {
+        // Use a payload char that never appears in the surrounding framing so the
+        // count of retained body bytes is unambiguous.
+        const big = "Z".repeat(500);
+        const fetchImpl = vi.fn(async () => ({
+            ok: true,
+            arrayBuffer: async () => new TextEncoder().encode(big).buffer,
+        }));
+        const parts = await buildFileContentParts([
+            {
+                url: "https://cdn/big.log",
+                name: "big.log",
+                contentType: "text/plain",
+                size: big.length,
+            },
+        ], { fetchImpl, maxTextBytes: 100 });
+        expect(parts[0]).toMatchObject({ type: "text" });
+        const text = parts[0].text;
+        expect(text).toContain("truncated");
+        expect(text).toContain("…(truncated)");
+        // Exactly 100 body bytes retained out of the original 500.
+        expect(text.match(/Z/g)?.length).toBe(100);
+    });
+    it("processes at most maxFiles attachments per message (default 5)", async () => {
+        const fetchImpl = vi.fn(async () => ({
+            ok: true,
+            arrayBuffer: async () => new Uint8Array([1, 2, 3]).buffer,
+        }));
+        // 7 attachments, default maxFiles is 5 → only the first 5 are processed.
+        const attachments = Array.from({ length: 7 }, (_, i) => ({
+            url: `https://cdn/x${i}.png`,
+            name: `x${i}.png`,
+            contentType: "image/png",
+            size: 3,
+        }));
+        const parts = await buildFileContentParts(attachments, { fetchImpl });
+        expect(parts).toHaveLength(5);
+        expect(fetchImpl).toHaveBeenCalledTimes(5);
+    });
+    it("surfaces an oversize skip as a note while still emitting a co-attached valid image", async () => {
+        const pngBytes = new Uint8Array([0x89, 0x50, 0x4e, 0x47]);
+        const fetchImpl = vi.fn(async () => ({
+            ok: true,
+            arrayBuffer: async () => pngBytes.buffer,
+        }));
+        const parts = await buildFileContentParts([
+            {
+                url: "https://cdn/big.png",
+                name: "big.png",
+                contentType: "image/png",
+                size: 50, // exceeds the tiny maxBytes below
+            },
+            {
+                url: "https://cdn/ok.png",
+                name: "ok.png",
+                contentType: "image/png",
+                size: pngBytes.length,
+            },
+        ], { fetchImpl, maxBytes: 10 });
+        // The oversize file becomes a skip note; the valid one still becomes image.
+        const note = parts.find((p) => p.type === "text");
+        expect(note).toBeDefined();
+        expect(note.text).toContain("skipped");
+        expect(note.text).toContain("big.png");
+        expect(parts.some((p) => p.type === "image")).toBe(true);
+        // Only the valid file was fetched — the oversize one was gated pre-fetch.
+        expect(fetchImpl).toHaveBeenCalledOnce();
+    });
+    it("surfaces an unsupported binary type as a note", async () => {
+        const fetchImpl = vi.fn();
+        const parts = await buildFileContentParts([
+            {
+                url: "https://cdn/app.bin",
+                name: "app.bin",
+                contentType: "application/octet-stream",
+                size: 3,
+            },
+        ], { fetchImpl });
+        expect(parts).toHaveLength(1);
+        const note = parts[0];
+        expect(note.type).toBe("text");
+        expect(note.text).toContain("unsupported type");
+        expect(note.text).toContain("app.bin");
+        // Unsupported types are gated pre-fetch.
+        expect(fetchImpl).not.toHaveBeenCalled();
+    });
+    it("decodes a .csv reported as application/octet-stream as a text part", async () => {
+        const csv = "a,b\n1,2";
+        const fetchImpl = vi.fn(async () => ({
+            ok: true,
+            arrayBuffer: async () => new TextEncoder().encode(csv).buffer,
+        }));
+        const parts = await buildFileContentParts([
+            {
+                url: "https://cdn/data.csv",
+                name: "data.csv",
+                contentType: "application/octet-stream",
+                size: csv.length,
+            },
+        ], { fetchImpl });
+        expect(parts[0]).toMatchObject({ type: "text" });
+        expect(JSON.stringify(parts[0])).toContain("a,b");
+    });
+});

package/dist/event-renderer.d.ts

@@ -0,0 +1,36 @@
+import type { RunRenderer } from "@copilotkit/channels";
+/**
+ * Minimal structural type for a Discord text-channel (or thread) so unit
+ * tests can inject a fake without opening a Gateway connection.
+ */
+export interface ChannelLike {
+    sendTyping(): Promise<void>;
+    send(payload: string | {
+        content: string;
+    }): Promise<{
+        id: string;
+        edit(p: string | {
+            content: string;
+        }): Promise<unknown>;
+    }>;
+}
+/**
+ * Construct a {@link RunRenderer} for a single agent run in Discord.
+ *
+ * The `subscriber` is passed to `runAgent`. After the run resolves, the
+ * run-loop reads `getCapturedToolCalls()` (filtering by which tools are
+ * registered) and `getPendingInterrupt()`. `markInterrupted()` is called
+ * when a new turn arrives for the same conversation while this run is
+ * still streaming — it appends a `_(interrupted)_` marker to any partial
+ * reply so the user sees a clear visual cue that the bot stopped.
+ */
+export declare function createRunRenderer(args: {
+    channel: ChannelLike;
+    /**
+     * Custom-event names that should be treated as interrupts — captured
+     * for later dispatch to an `InterruptHandler`. Defaults to just
+     * `on_interrupt` (the name LangGraph's AG-UI adapter emits).
+     */
+    interruptEventNames?: ReadonlySet<string>;
+}): RunRenderer;
+//# sourceMappingURL=event-renderer.d.ts.map

package/dist/event-renderer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-renderer.d.ts","sourceRoot":"","sources":["../src/event-renderer.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,WAAW,EAGZ,MAAM,sBAAsB,CAAC;AAwB9B;;;GAGG;AACH,MAAM,WAAW,WAAW;IAC1B,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5B,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG;QAAE,OAAO,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC;QACnD,EAAE,EAAE,MAAM,CAAC;QACX,IAAI,CAAC,CAAC,EAAE,MAAM,GAAG;YAAE,OAAO,EAAE,MAAM,CAAA;SAAE,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;KACzD,CAAC,CAAC;CACJ;AAED;;;;;;;;;GASG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE;IACtC,OAAO,EAAE,WAAW,CAAC;IACrB;;;;OAIG;IACH,mBAAmB,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;CAC3C,GAAG,WAAW,CAqQd"}

package/dist/event-renderer.js

@@ -0,0 +1,270 @@
+import { ChunkedMessageStream } from "./chunked-message-stream.js";
+import { discordMarkdown } from "./markdown.js";
+import { autoCloseOpenMarkdown } from "./auto-close-streaming.js";
+/**
+ * The display-transform applied to every streaming chunk before it hits
+ * `message.edit`. Composed of two pure functions:
+ *
+ *   1. `autoCloseOpenMarkdown` — closes dangling fenced code, inline
+ *      backticks, bold/italic/strike so a mid-stream buffer renders as
+ *      valid Discord markdown (instead of leaking code-styling through the
+ *      rest of the message). When the agent eventually emits the real
+ *      close marker the buffer becomes balanced and this step adds
+ *      nothing, so the committed message is never double-closed.
+ *
+ *   2. `discordMarkdown` — translates the (now-balanced) markdown for
+ *      Discord (GFM table → fenced block; everything else is identity).
+ */
+const displayTransform = (s) => discordMarkdown(autoCloseOpenMarkdown(s));
+const INTERRUPTED_SUFFIX = "\n_(interrupted)_";
+/**
+ * Construct a {@link RunRenderer} for a single agent run in Discord.
+ *
+ * The `subscriber` is passed to `runAgent`. After the run resolves, the
+ * run-loop reads `getCapturedToolCalls()` (filtering by which tools are
+ * registered) and `getPendingInterrupt()`. `markInterrupted()` is called
+ * when a new turn arrives for the same conversation while this run is
+ * still streaming — it appends a `_(interrupted)_` marker to any partial
+ * reply so the user sees a clear visual cue that the bot stopped.
+ */
+export function createRunRenderer(args) {
+    const { channel } = args;
+    const interruptEventNames = args.interruptEventNames ?? new Set(["on_interrupt"]);
+    // ── Typing heartbeat ───────────────────────────────────────────────────
+    // Discord's typing indicator auto-expires after ~10 s. A single
+    // sendTyping() on run start leaves dead air whenever the agent spends
+    // longer than that reasoning or waiting on a slow MCP/tool call before
+    // its first token — the indicator vanishes and the bot looks crashed.
+    // So we refresh typing on an interval for the lifetime of the run and
+    // stop on the first terminal signal (RUN_FINISHED / RUN_ERROR / abort).
+    // Best-effort: a failing sendTyping must never crash the run. A refresh
+    // cap bounds the worst case if no terminal event ever arrives.
+    const TYPING_REFRESH_MS = 8000;
+    const TYPING_MAX_REFRESHES = 40; // ~5.3 min safety cap against a leaked timer
+    let typingTimer;
+    let typingRefreshes = 0;
+    const sendTypingSafe = () => {
+        void Promise.resolve(channel.sendTyping()).catch(() => {
+            /* best-effort */
+        });
+    };
+    const startTyping = () => {
+        if (typingTimer)
+            return;
+        typingRefreshes = 0;
+        sendTypingSafe();
+        typingTimer = setInterval(() => {
+            if (++typingRefreshes >= TYPING_MAX_REFRESHES) {
+                stopTyping();
+                return;
+            }
+            sendTypingSafe();
+        }, TYPING_REFRESH_MS);
+        // Don't keep the process alive solely for the typing heartbeat.
+        typingTimer.unref?.();
+    };
+    const stopTyping = () => {
+        if (typingTimer) {
+            clearInterval(typingTimer);
+            typingTimer = undefined;
+        }
+    };
+    /** Per-AG-UI-message accumulated text (we accumulate deltas locally). */
+    const buffers = new Map();
+    /** Per-AG-UI-message ChunkedMessageStream. Lazily created on first content. */
+    const streams = new Map();
+    /**
+     * One handle per posted Discord message, keyed by the id returned from
+     * `channel.send`. A long agent reply (>2000 chars) is split by
+     * {@link ChunkedMessageStream} into several Discord messages, and
+     * `updateAt(id, …)` must edit the message that owns `id` — NOT a single
+     * per-AG-UI-message handle, which every new chunk would overwrite,
+     * routing all edits to the last-posted message. Mirrors the `handles`
+     * Map in adapter.ts `stream()`. Shared across every stream in this run
+     * (Discord ids are globally unique, so there's no collision risk).
+     */
+    const handles = new Map();
+    /**
+     * Once a stream has been "finalised" (either via TEXT_MESSAGE_END or via
+     * markInterrupted), we drop it. Late-arriving events for the same
+     * messageId are ignored — they'd otherwise reopen a closed stream and
+     * post a fresh placeholder *after* the user already saw the message
+     * was over.
+     */
+    const finalised = new Set();
+    /**
+     * Set when the caller intentionally aborted the run (i.e. a new turn
+     * arrived for the same conversation). Suppresses further AG-UI event
+     * processing — the `_(interrupted)_` marker conveys the state visually.
+     */
+    let aborted = false;
+    /** Tool calls observed in this run, in event order. */
+    const capturedToolCalls = [];
+    /**
+     * Interrupt observed via a matching `onCustomEvent`. The React
+     * `useInterrupt` pattern buffers locally and commits on run-finalize,
+     * which we mirror via this single-slot variable — the run-loop reads it
+     * after `runAgent` resolves.
+     */
+    let pendingInterrupt;
+    const ensureStream = (messageId) => {
+        if (finalised.has(messageId))
+            return undefined;
+        let s = streams.get(messageId);
+        if (!s) {
+            s = new ChunkedMessageStream({
+                postPlaceholder: async (text) => {
+                    const m = await channel.send(text);
+                    handles.set(m.id, m);
+                    return m.id;
+                },
+                updateAt: async (id, text) => {
+                    await handles.get(id)?.edit(text);
+                },
+                transform: displayTransform,
+            });
+            streams.set(messageId, s);
+        }
+        return s;
+    };
+    // ── Tool-call dedup (verbatim from bot-slack/src/event-renderer.ts) ──
+    // Keep a single entry per toolCallId, overwriting on ARGS and END so
+    // the captured entry always holds the latest parsed shape.
+    const captureToolCall = (toolCallId, toolCallName, toolCallArgs) => {
+        const existing = capturedToolCalls.find((c) => c.toolCallId === toolCallId);
+        if (existing) {
+            existing.toolCallName = toolCallName;
+            existing.toolCallArgs = toolCallArgs;
+        }
+        else {
+            capturedToolCalls.push({ toolCallId, toolCallName, toolCallArgs });
+        }
+    };
+    const subscriber = {
+        // ── 0. Run lifecycle: typing heartbeat ────────────────────────────
+        // Start the typing heartbeat so the indicator stays alive through long
+        // tool/MCP calls (see startTyping above), not just the first ~10 s.
+        onRunStartedEvent() {
+            if (aborted)
+                return;
+            startTyping();
+        },
+        // Stop the heartbeat once the run completes so the indicator doesn't
+        // linger past the final message.
+        onRunFinishedEvent() {
+            stopTyping();
+        },
+        // ── 1. Text streaming ──────────────────────────────────────────────
+        onTextMessageStartEvent({ event }) {
+            if (aborted)
+                return;
+            buffers.set(event.messageId, "");
+        },
+        onTextMessageContentEvent({ event }) {
+            if (aborted)
+                return;
+            const next = (buffers.get(event.messageId) ?? "") + (event.delta ?? "");
+            buffers.set(event.messageId, next);
+            ensureStream(event.messageId)?.append(next);
+        },
+        async onTextMessageEndEvent({ event }) {
+            if (aborted)
+                return;
+            const stream = streams.get(event.messageId);
+            if (stream) {
+                await stream.finish();
+                streams.delete(event.messageId);
+            }
+            buffers.delete(event.messageId);
+            finalised.add(event.messageId);
+        },
+        // ── 2. Tool-call capture ──────────────────────────────────────────
+        onToolCallArgsEvent({ event, toolCallName, partialToolCallArgs }) {
+            if (aborted)
+                return;
+            // Accumulate partial args so the captured entry tracks the latest
+            // parsed shape as args stream in. We keep a single entry per
+            // toolCallId, overwriting `toolCallArgs`.
+            captureToolCall(event.toolCallId, toolCallName, (partialToolCallArgs ?? {}));
+        },
+        async onToolCallEndEvent({ event, toolCallName, toolCallArgs }) {
+            if (aborted)
+                return;
+            // Capture EVERY tool call — the run-loop filters by which tools are
+            // registered. A tool with no `args` events still lands here.
+            captureToolCall(event.toolCallId, toolCallName, (toolCallArgs ?? {}));
+        },
+        // ── 3. Interrupts (LangGraph `interrupt()` → AG-UI custom event) ─
+        // Verbatim from bot-slack/src/event-renderer.ts.
+        onCustomEvent({ event }) {
+            if (aborted)
+                return;
+            const e = event;
+            if (!e.name || !interruptEventNames.has(e.name))
+                return;
+            // LangGraph's AG-UI adapter ships the interrupt value as a JSON
+            // string in some shapes (and as an object in others). Normalize
+            // here so downstream schema validation always sees the parsed shape.
+            let value = e.value;
+            if (typeof value === "string") {
+                try {
+                    value = JSON.parse(value);
+                }
+                catch {
+                    // Leave it as a string — the handler's schema will reject it
+                    // explicitly with a clearer error.
+                }
+            }
+            pendingInterrupt = { eventName: e.name, value };
+        },
+        // ── 4. Errors ─────────────────────────────────────────────────────
+        // When an agent run fails (RUN_ERROR), surface a visible warning in
+        // the channel so the user isn't left staring at an expired typing
+        // indicator with no feedback. Suppressed when the abort was
+        // self-initiated — the `_(interrupted)_` marker is the user-visible
+        // signal in that case. Best-effort, like the typing call: a failure
+        // here must never crash the run.
+        async onRunErrorEvent({ event }) {
+            stopTyping();
+            if (aborted)
+                return;
+            try {
+                await channel.send(`⚠️ Agent error: ${event.message ?? "unknown error"}`);
+            }
+            catch (err) {
+                console.error("[discord-renderer] error notice failed:", err);
+            }
+        },
+    };
+    return {
+        subscriber,
+        getCapturedToolCalls: () => capturedToolCalls,
+        getPendingInterrupt: () => pendingInterrupt,
+        clearPendingInterrupt: () => {
+            pendingInterrupt = undefined;
+        },
+        async markInterrupted() {
+            // Idempotent. Mark BEFORE any await so subsequent subscriber
+            // callbacks see the flag and bail.
+            if (aborted)
+                return;
+            aborted = true;
+            stopTyping();
+            // For each in-flight text-message stream, append the interrupted
+            // marker and drain. Streams that have no content yet are silently
+            // dropped (the bot never posted anything for them).
+            const tasks = [];
+            for (const [id, stream] of Array.from(streams.entries())) {
+                const buf = buffers.get(id) ?? "";
+                if (buf.length > 0) {
+                    stream.append(buf + INTERRUPTED_SUFFIX);
+                    tasks.push(stream.finish());
+                }
+                streams.delete(id);
+                finalised.add(id);
+            }
+            buffers.clear();
+            await Promise.all(tasks);
+        },
+    };
+}

package/dist/event-renderer.test.d.ts

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

package/dist/event-renderer.test.d.ts.map

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