@copilotkit/channels-discord 0.0.2

package/dist/adapter.test.js

@@ -0,0 +1,343 @@
+import { describe, it, expect, vi } from "vitest";
+import { MessageFlags } from "discord.js";
+import { DiscordAdapter, discord } from "./adapter.js";
+function fakeClient() {
+    const handlers = {};
+    return {
+        on(e, cb) {
+            handlers[e] = cb;
+        },
+        once(e, cb) {
+            handlers[e] = cb;
+        },
+        login: vi.fn(async () => "ok"),
+        destroy: vi.fn(async () => { }),
+        user: { id: "bot-1" },
+        channels: {
+            fetch: vi.fn(async () => ({
+                id: "c1",
+                send: vi.fn(async () => ({ id: "m1" })),
+            })),
+        },
+        emit(e, a) {
+            handlers[e]?.(a);
+        },
+    };
+}
+const sink = () => ({
+    onTurn: vi.fn(),
+    onInteraction: vi.fn(),
+    onCommand: vi.fn(),
+    onModalSubmit: vi.fn(),
+});
+describe("DiscordAdapter", () => {
+    it("advertises Discord capabilities", () => {
+        const a = new DiscordAdapter({ botToken: "t", appId: "app" });
+        expect(a.platform).toBe("discord");
+        expect(a.capabilities.supportsModals).toBe(true);
+        expect(a.capabilities.supportsTyping).toBe(true);
+        expect(a.capabilities.supportsReactions).toBe(true);
+        expect(a.capabilities.supportsEphemeral).toBe(false);
+        expect(a.capabilities.supportsStreaming).toBe(true);
+        expect(a.capabilities.maxBlocksPerMessage).toBe(40);
+        expect(a.ackDeadlineMs).toBe(3000);
+    });
+    it("renders IR to a components-v2 container", () => {
+        const a = new DiscordAdapter({ botToken: "t", appId: "app" });
+        const out = a.render([
+            {
+                type: "message",
+                props: { children: { type: "text", props: { value: "hi" } } },
+            },
+        ]);
+        expect(out).toBeTruthy(); // ContainerBuilder
+    });
+    it("logs in and captures the bot id on start, publishing commands on ready", async () => {
+        const client = fakeClient();
+        const put = vi.fn(async () => { });
+        const a = new DiscordAdapter({ botToken: "t", appId: "app" }, { client: client, rest: { put } });
+        await a.start(sink());
+        expect(client.login).toHaveBeenCalledWith("t");
+        expect(put).not.toHaveBeenCalled();
+        // Stash a non-empty command list — publishCommands guards an empty list (an
+        // empty PUT would clear all of the bot's commands), so a command must be
+        // registered for the once("ready") publish to PUT anything.
+        a.registerCommands([{ name: "agent", description: "x" }]);
+        client.emit("ready", client); // discord.js passes the ready client
+        // ready handler is async; flush microtasks
+        await Promise.resolve();
+        await Promise.resolve();
+        expect(put).toHaveBeenCalledTimes(1);
+    });
+    it("discord() factory returns an adapter", () => {
+        expect(discord({ botToken: "t", appId: "app" })).toBeInstanceOf(DiscordAdapter);
+    });
+    it("stream() edits each posted message with ITS own chunk, not all-on-first", async () => {
+        // Each send() mints a distinct id and its own edit spy, so we can assert
+        // the per-message Map wiring (chunk N → message N), not chunk-on-#0.
+        const posted = [];
+        let n = 0;
+        const channel = {
+            id: "c1",
+            send: vi.fn(async () => {
+                const m = { id: `m${++n}`, edit: vi.fn(async () => { }) };
+                posted.push(m);
+                return m;
+            }),
+            messages: { fetch: vi.fn() },
+        };
+        const client = {
+            ...fakeClient(),
+            channels: { fetch: vi.fn(async () => channel) },
+        };
+        const a = new DiscordAdapter({ botToken: "t", appId: "app" }, { client: client, rest: { put: vi.fn() } });
+        // Two chunks: >2000 chars forces ChunkedMessageStream to post a second
+        // Discord message. Distinct markers per half let us check routing.
+        const first = "A".repeat(1500) + "\n";
+        const second = "B".repeat(1500);
+        async function* chunks() {
+            yield first;
+            yield second;
+        }
+        const ref = await a.stream({ channelId: "c1" }, chunks());
+        // Two messages posted, ref points at the first.
+        expect(posted.length).toBe(2);
+        expect(ref.id).toBe("m1");
+        // The first message's final edit must NOT contain the second chunk's
+        // marker, and the second message's final edit must contain it. If the
+        // Map were ignored (old bug), every edit would land on message #0.
+        const firstFinal = posted[0].edit.mock.calls.at(-1)?.[0];
+        const secondFinal = posted[1].edit.mock.calls.at(-1)?.[0];
+        expect(firstFinal).toContain("A");
+        expect(firstFinal).not.toContain("B");
+        expect(secondFinal).toContain("B");
+    });
+    it("resolveUser does NOT cache the bare-id fallback on transient fetch failure", async () => {
+        const fetch = vi
+            .fn()
+            // first call throws → bare-id fallback, must not be cached
+            .mockRejectedValueOnce(new Error("rate limited"))
+            // second call succeeds → real user
+            .mockResolvedValueOnce({ id: "u1", globalName: "Ada", username: "ada" });
+        const client = { ...fakeClient(), users: { fetch } };
+        const a = new DiscordAdapter({ botToken: "t", appId: "app" }, { client: client, rest: { put: vi.fn() } });
+        const first = await a.resolveUser("u1");
+        expect(first).toEqual({ id: "u1" }); // bare-id fallback
+        const second = await a.resolveUser("u1");
+        // A retry happened (not served from cache) and resolved the real user.
+        expect(fetch).toHaveBeenCalledTimes(2);
+        expect(second).toEqual({ id: "u1", name: "Ada", handle: "ada" });
+    });
+    it("getMessages excludes the bot's own streaming placeholders from history", async () => {
+        // Mix: a user message, a real bot reply, and a bot streaming placeholder.
+        // fetch() returns a Map-like with values(); getMessages reverses + filters.
+        const messages = [
+            {
+                id: "m1",
+                content: "hey bot",
+                author: { id: "u1", bot: false, username: "ann", globalName: "Ann" },
+            },
+            {
+                id: "m2",
+                content: "_thinking…_", // bot placeholder — must be excluded
+                author: { id: "bot-1", bot: true, username: "bot" },
+            },
+            {
+                id: "m3",
+                content: "here is the real answer",
+                author: { id: "bot-1", bot: true, username: "bot" },
+            },
+        ];
+        const channel = {
+            id: "c1",
+            send: vi.fn(async () => ({ id: "x" })), // fetchSendable requires `send`
+            messages: {
+                fetch: vi.fn(async () => new Map(messages.map((m) => [m.id, m]))),
+            },
+        };
+        const client = {
+            ...fakeClient(),
+            channels: { fetch: vi.fn(async () => channel) },
+        };
+        const a = new DiscordAdapter({ botToken: "t", appId: "app" }, { client: client, rest: { put: vi.fn() } });
+        const out = await a.getMessages({ channelId: "c1" });
+        const texts = out.map((m) => m.text);
+        expect(texts).toContain("hey bot");
+        expect(texts).toContain("here is the real answer");
+        expect(texts).not.toContain("_thinking…_");
+        expect(out).toHaveLength(2);
+    });
+    it("addReaction falls back to the target channel when the reacted ref has no channelId", async () => {
+        // The reacted ref the bot-ui example sends is just `{ id }` (no channelId);
+        // the channel must come from the conversation's reply target — parity with
+        // Slack/Telegram. Regression: previously Discord resolved fetchSendable("")
+        // and the react silently failed (acks never fired on Discord).
+        const message = { react: vi.fn(async () => undefined) };
+        const channel = {
+            id: "c1",
+            send: vi.fn(async () => ({ id: "x" })),
+            messages: { fetch: vi.fn(async () => message) },
+        };
+        const channelsFetch = vi.fn(async (id) => {
+            if (!id)
+                throw new Error("channel  is not sendable"); // empty id is the bug
+            return channel;
+        });
+        const client = { ...fakeClient(), channels: { fetch: channelsFetch } };
+        const a = new DiscordAdapter({ botToken: "t", appId: "app" }, { client: client, rest: { put: vi.fn() } });
+        const res = await a.addReaction({ channelId: "c1" }, { id: "m1" }, "eyes");
+        expect(res).toEqual({ ok: true });
+        // Resolved the TARGET channel, never the empty string.
+        expect(channelsFetch).toHaveBeenCalledWith("c1");
+        expect(channelsFetch).not.toHaveBeenCalledWith("");
+        expect(message.react).toHaveBeenCalled();
+    });
+    it("interactionCreate dispatch failures are caught, not left unhandled", async () => {
+        const client = fakeClient();
+        const a = new DiscordAdapter({ botToken: "t", appId: "app" }, { client: client, rest: { put: vi.fn() } });
+        const s = sink();
+        // sink.onInteraction rejects — without the try/catch this becomes an
+        // unhandled promise rejection inside the event handler.
+        s.onInteraction.mockRejectedValue(new Error("dispatch boom"));
+        const errSpy = vi.spyOn(console, "error").mockImplementation(() => { });
+        await a.start(s);
+        // A well-formed button interaction that decodes to an event.
+        const deferUpdate = vi.fn(async () => { });
+        const interaction = {
+            isButton: () => true,
+            isStringSelectMenu: () => false,
+            id: "int-1",
+            customId: "btn-1",
+            channelId: "c1",
+            user: { id: "u1", username: "ada" },
+            message: { id: "m1" },
+            deferUpdate,
+        };
+        // emit() invokes the (async) handler synchronously; the body runs across
+        // several microtask turns (deferUpdate → decode → dispatch → catch). If the
+        // rejection escaped the handler, it would surface as an unhandled rejection
+        // (and crash under --unhandled-rejections=throw) rather than the logged path.
+        client.emit("interactionCreate", interaction);
+        await Promise.resolve();
+        await Promise.resolve();
+        await Promise.resolve();
+        expect(deferUpdate).toHaveBeenCalledTimes(1);
+        expect(s.onInteraction).toHaveBeenCalledTimes(1);
+        expect(errSpy).toHaveBeenCalledWith("[bot-discord] interaction dispatch failed:", expect.any(Error));
+        errSpy.mockRestore();
+    });
+    // A modal opened from a slash command yields a ModalSubmitInteraction with
+    // no originating message — `deferUpdate()` is invalid there and throws. The
+    // ack must use `deferReply` (ephemeral) for that origin, and must never throw
+    // uncaught.
+    function fakeModalSubmit(over) {
+        return {
+            isButton: () => false,
+            isStringSelectMenu: () => false,
+            isModalSubmit: () => true,
+            customId: "triage",
+            channelId: "c1",
+            guildId: "g1",
+            user: { id: "u1", username: "ada" },
+            fields: {
+                fields: new Map([["summary", { customId: "summary", value: "x" }]]),
+            },
+            replied: false,
+            deferred: false,
+            ...over,
+        };
+    }
+    it("modal-submit from a slash command acks with deferReply (ephemeral), not deferUpdate", async () => {
+        const client = fakeClient();
+        const a = new DiscordAdapter({ botToken: "t", appId: "app" }, { client: client, rest: { put: vi.fn() } });
+        const s = sink();
+        await a.start(s);
+        // Slash-command origin: isFromMessage() === false. deferUpdate would throw
+        // for such an interaction in discord.js, so simulate that to prove the
+        // correct method is chosen (and that a stray call would surface).
+        const deferReply = vi.fn(async (_opts) => { });
+        const deferUpdate = vi.fn(async () => {
+            throw new Error("interaction not from message");
+        });
+        const interaction = fakeModalSubmit({
+            isFromMessage: () => false,
+            deferReply,
+            deferUpdate,
+        });
+        client.emit("interactionCreate", interaction);
+        for (let i = 0; i < 5; i++)
+            await Promise.resolve();
+        expect(s.onModalSubmit).toHaveBeenCalledTimes(1);
+        expect(deferReply).toHaveBeenCalledTimes(1);
+        // ephemeral flag passed
+        expect(deferReply.mock.calls[0]?.[0]).toMatchObject({
+            flags: MessageFlags.Ephemeral,
+        });
+        expect(deferUpdate).not.toHaveBeenCalled();
+    });
+    it("modal-submit from a message component acks with deferUpdate, not deferReply", async () => {
+        const client = fakeClient();
+        const a = new DiscordAdapter({ botToken: "t", appId: "app" }, { client: client, rest: { put: vi.fn() } });
+        const s = sink();
+        await a.start(s);
+        const deferReply = vi.fn(async () => { });
+        const deferUpdate = vi.fn(async () => { });
+        const interaction = fakeModalSubmit({
+            isFromMessage: () => true,
+            deferReply,
+            deferUpdate,
+        });
+        client.emit("interactionCreate", interaction);
+        for (let i = 0; i < 5; i++)
+            await Promise.resolve();
+        expect(s.onModalSubmit).toHaveBeenCalledTimes(1);
+        expect(deferUpdate).toHaveBeenCalledTimes(1);
+        expect(deferReply).not.toHaveBeenCalled();
+    });
+    it("openModal opens a modal for a slash-command interaction (commandPending registry)", async () => {
+        // The bug: openModal only consulted the component registry (`pending`), so a
+        // modal opened from a slash command — whose live interaction lives in
+        // `commandPending` — silently failed. openModal must try BOTH registries.
+        const client = fakeClient();
+        const a = new DiscordAdapter({ botToken: "t", appId: "app" }, { client: client, rest: { put: vi.fn() } });
+        // `commandPending` is constructed in start(); spin it up with the fake client.
+        await a.start(sink());
+        // Register a live slash-command interaction in the COMMAND registry only
+        // (not the component `pending` one), then open a modal against its trigger.
+        const showModal = vi.fn(async () => { });
+        const triggerId = a.commandPending.register({ id: "cmdTrigger", showModal });
+        // A minimal valid modal IR: a <Modal> root with no children renders fine
+        // (zero text inputs is allowed; renderDiscordModal only throws on
+        // unsupported elements or >5 inputs).
+        const modalIr = [
+            { type: "modal", props: { callbackId: "x", title: "t", children: [] } },
+        ];
+        const res = await a.openModal({ channelId: "c1" }, triggerId, modalIr);
+        expect(showModal).toHaveBeenCalledTimes(1);
+        expect(res).toEqual({ ok: true });
+    });
+    it("registerCommands never clears on empty, and publishes when already ready", async () => {
+        const client = fakeClient();
+        const put = vi.fn(async (_route, _opts) => undefined);
+        const a = new DiscordAdapter({ botToken: "t", appId: "app" }, { client: client, rest: { put } });
+        await a.start(sink());
+        // (i) An empty command list must NOT PUT — an empty PUT clears all of the
+        // bot's registered commands. Register empty, then fire `ready`.
+        a.registerCommands([]);
+        client.emit("ready", client);
+        await Promise.resolve();
+        await Promise.resolve();
+        expect(put).not.toHaveBeenCalled();
+        // (ii) Registering after `ready` must publish immediately (the once("ready")
+        // publish already ran, so a later registerCommands has to PUT itself).
+        a.registerCommands([{ name: "agent", description: "x" }]);
+        await Promise.resolve();
+        await Promise.resolve();
+        expect(put).toHaveBeenCalledTimes(1);
+        // The published body carries the registered command.
+        const body = put.mock.calls[0]?.[1];
+        expect(body.body).toEqual([
+            expect.objectContaining({ name: "agent", description: "x" }),
+        ]);
+    });
+});

package/dist/auto-close-streaming.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Streaming-polish layer: while an agent is mid-stream, the buffer is
+ * usually an *unfinished* markdown document — an open code fence, an
+ * unclosed `**`, etc. If we send the unbalanced text straight to Discord,
+ * the rest of the message renders broken (a stray ``` will turn the rest
+ * of the Discord message into a code block until the closer arrives).
+ *
+ * `autoCloseOpenMarkdown` returns a balanced copy of the buffer by
+ * appending the minimum set of closers needed so that the markdown is
+ * well-formed for display. When the agent later emits the real closer,
+ * the buffer becomes balanced on its own and this function adds nothing
+ * — i.e. no double-close in the committed Discord message.
+ *
+ * Operates in **markdown space** (i.e. on the raw text from the agent).
+ * Discord renders a Markdown subset natively, so a balanced document
+ * displays correctly without further translation.
+ *
+ * What it handles, in priority order:
+ *
+ *   1. Unclosed fenced code blocks ``` … (most severe — leaks code styling
+ *      through the rest of the Discord message)
+ *   2. Unclosed inline code `…`
+ *   3. Unclosed bold `**…` / `__…`
+ *   4. Unclosed italic `*…` / `_…`
+ *   5. Unclosed strike `~~…`
+ *
+ * Heuristics:
+ *
+ *   - A marker with no content after it (e.g. trailing `**`) is **not**
+ *     closed — the agent might be just opening the bracket; closing would
+ *     produce a transient `****` which looks worse than `**`.
+ *   - Markers inside code/fence regions don't count.
+ *   - When closing, we emit closers in reverse stack order (innermost
+ *     first) so the rendered structure is well-nested.
+ */
+export declare function autoCloseOpenMarkdown(text: string): string;
+/**
+ * What markdown context is *still open* at the end of `text`? Used to
+ * decide what opening marker(s) the NEXT chunk needs prepended when we
+ * split a long buffer across multiple Discord messages mid-formatting
+ * — without this, a chunk boundary inside a ` ```python … ``` ` block
+ * would have the second Discord message start with raw code that Discord
+ * renders as plain text.
+ */
+export interface OpenMarkdownContext {
+    /** If inside an unclosed fence, the language tag (may be ""). null otherwise. */
+    fenceLang: string | null;
+    /** True if an unclosed single-backtick inline-code span is in flight. */
+    inlineCode: boolean;
+    /** Bold/italic/strike markers still open, in stack order (outermost first). */
+    brackets: string[];
+}
+export declare function detectOpenContext(text: string): OpenMarkdownContext;
+/**
+ * Render the opener prefix for a continuation chunk so it can stand on
+ * its own as a self-renderable markdown fragment. E.g. for an open
+ * `` ```python `` fence, returns ` ```python\n `; for an open `**` bold,
+ * returns `**`.
+ */
+export declare function renderContextOpener(ctx: OpenMarkdownContext): string;
+//# sourceMappingURL=auto-close-streaming.d.ts.map

package/dist/auto-close-streaming.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auto-close-streaming.d.ts","sourceRoot":"","sources":["../src/auto-close-streaming.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAKH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CA+E1D;AAqFD;;;;;;;GAOG;AACH,MAAM,WAAW,mBAAmB;IAClC,iFAAiF;IACjF,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,yEAAyE;IACzE,UAAU,EAAE,OAAO,CAAC;IACpB,+EAA+E;IAC/E,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB;AAED,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,mBAAmB,CAiCnE;AAiCD;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,mBAAmB,GAAG,MAAM,CAUpE"}

package/dist/auto-close-streaming.js

@@ -0,0 +1,276 @@
+/**
+ * Streaming-polish layer: while an agent is mid-stream, the buffer is
+ * usually an *unfinished* markdown document — an open code fence, an
+ * unclosed `**`, etc. If we send the unbalanced text straight to Discord,
+ * the rest of the message renders broken (a stray ``` will turn the rest
+ * of the Discord message into a code block until the closer arrives).
+ *
+ * `autoCloseOpenMarkdown` returns a balanced copy of the buffer by
+ * appending the minimum set of closers needed so that the markdown is
+ * well-formed for display. When the agent later emits the real closer,
+ * the buffer becomes balanced on its own and this function adds nothing
+ * — i.e. no double-close in the committed Discord message.
+ *
+ * Operates in **markdown space** (i.e. on the raw text from the agent).
+ * Discord renders a Markdown subset natively, so a balanced document
+ * displays correctly without further translation.
+ *
+ * What it handles, in priority order:
+ *
+ *   1. Unclosed fenced code blocks ``` … (most severe — leaks code styling
+ *      through the rest of the Discord message)
+ *   2. Unclosed inline code `…`
+ *   3. Unclosed bold `**…` / `__…`
+ *   4. Unclosed italic `*…` / `_…`
+ *   5. Unclosed strike `~~…`
+ *
+ * Heuristics:
+ *
+ *   - A marker with no content after it (e.g. trailing `**`) is **not**
+ *     closed — the agent might be just opening the bracket; closing would
+ *     produce a transient `****` which looks worse than `**`.
+ *   - Markers inside code/fence regions don't count.
+ *   - When closing, we emit closers in reverse stack order (innermost
+ *     first) so the rendered structure is well-nested.
+ */
+const SENTINEL_FENCE = "
";
+const SENTINEL_INLINE = "";
+export function autoCloseOpenMarkdown(text) {
+    if (!text)
+        return text;
+    // ── 1. Fenced code blocks ──────────────────────────────────────────
+    // Pair complete fences first, then determine if there's a dangling open.
+    const fences = [];
+    let work = text.replace(/```[\s\S]*?```/g, (m) => {
+        fences.push(m);
+        return `${SENTINEL_FENCE}${fences.length - 1}${SENTINEL_FENCE}`;
+    });
+    const openFenceIdx = work.indexOf("```");
+    let openFenceTail = "";
+    if (openFenceIdx >= 0) {
+        openFenceTail = work.slice(openFenceIdx);
+        work = work.slice(0, openFenceIdx);
+    }
+    // ── 2. Inline code regions ─────────────────────────────────────────
+    const inlines = [];
+    work = work.replace(/`[^`\n]+`/g, (m) => {
+        inlines.push(m);
+        return `${SENTINEL_INLINE}${inlines.length - 1}${SENTINEL_INLINE}`;
+    });
+    // Dangling open inline backtick? Only count if there's content after it.
+    const openBacktickIdx = work.indexOf("`");
+    let openBacktickTail = "";
+    if (openBacktickIdx >= 0) {
+        openBacktickTail = work.slice(openBacktickIdx);
+        work = work.slice(0, openBacktickIdx);
+    }
+    // ── 3. Bold / italic / strike via stack scan ──────────────────────
+    const stack = scanBracketStack(work);
+    // Closers in pop order (innermost first) so the rendered structure
+    // nests correctly: e.g. `**bold _italic` → close `_` then `**`.
+    const closers = stack.slice().toReversed().join("");
+    // ── 4. Reassemble ─────────────────────────────────────────────────
+    // Insert closers BEFORE any trailing whitespace on the work text so a
+    // buffer like "**bold " produces "**bold**" rather than "**bold **".
+    let output = work;
+    if (closers) {
+        const trail = output.match(/\s*$/)?.[0] ?? "";
+        output = output.slice(0, output.length - trail.length) + closers + trail;
+    }
+    // Inline backtick: if dangling open has content after it, close it.
+    if (openBacktickTail) {
+        output += openBacktickTail;
+        if (hasContentAfterMarker(openBacktickTail, "`")) {
+            output += "`";
+        }
+    }
+    // Restore inline regions (paired backticks that were untouched).
+    output = output.replace(new RegExp(`${SENTINEL_INLINE}(\\d+)${SENTINEL_INLINE}`, "g"), (_, idx) => inlines[Number(idx)] ?? "");
+    // Fenced code: if there's real code content (text after the optional
+    // language line), close the fence. A buffer like "```py" or "```py\n"
+    // is "just opened" and should NOT yet be closed.
+    if (openFenceTail) {
+        output += openFenceTail;
+        if (hasFenceCodeContent(openFenceTail)) {
+            output += openFenceTail.endsWith("\n") ? "```" : "\n```";
+        }
+    }
+    // Restore paired fences.
+    output = output.replace(new RegExp(`${SENTINEL_FENCE}(\\d+)${SENTINEL_FENCE}`, "g"), (_, idx) => fences[Number(idx)] ?? "");
+    return output;
+}
+/**
+ * Walks `text` left-to-right and returns the unbalanced bracket stack.
+ * Recognised markers (longer ones first): `**`, `__`, `~~`, then `*`, `_`.
+ *
+ * Standalone single-char markers don't match when they're part of the
+ * doubled variant — `**` is parsed as one bold marker, not two italics.
+ */
+function scanBracketStack(text) {
+    // Each entry remembers the marker AND the position where it was pushed
+    // during the scan. Tracking the actual push position is required for the
+    // trailing-strip step below: a single-char marker (`*`) is a substring of
+    // its doubled variant (`**`), so `text.lastIndexOf("*")` could match the
+    // `*` inside a later `**` and wrongly classify a marker with real content
+    // as empty (e.g. `"*ab**"` would lose its open italic).
+    const stack = [];
+    const tryToggle = (m, index) => {
+        if (stack[stack.length - 1]?.marker === m)
+            stack.pop();
+        else
+            stack.push({ marker: m, index });
+    };
+    let i = 0;
+    while (i < text.length) {
+        if (text.startsWith("**", i)) {
+            tryToggle("**", i);
+            i += 2;
+        }
+        else if (text.startsWith("__", i)) {
+            tryToggle("__", i);
+            i += 2;
+        }
+        else if (text.startsWith("~~", i)) {
+            tryToggle("~~", i);
+            i += 2;
+        }
+        else if (text[i] === "*") {
+            tryToggle("*", i);
+            i += 1;
+        }
+        else if (text[i] === "_") {
+            tryToggle("_", i);
+            i += 1;
+        }
+        else {
+            i += 1;
+        }
+    }
+    // Strip any marker at the top of the stack that has NO content after it
+    // (i.e. it appears at the very end of the buffer with only whitespace
+    // following). Closing those would produce a transient `****`-style
+    // artefact that looks worse than the open `**`. We use the stored push
+    // index (not lastIndexOf) so substring markers can't be mis-located.
+    while (stack.length > 0) {
+        const top = stack[stack.length - 1];
+        const after = text.slice(top.index + top.marker.length);
+        if (/^\s*$/.test(after)) {
+            stack.pop();
+        }
+        else {
+            break;
+        }
+    }
+    return stack.map((e) => e.marker);
+}
+function hasContentAfterMarker(tail, marker) {
+    if (!tail.startsWith(marker))
+        return false;
+    const after = tail.slice(marker.length);
+    return /\S/.test(after);
+}
+/**
+ * True if a `\`\`\`<lang>?\n<content>` buffer has actual code content
+ * past the optional language line. We treat the first newline as the
+ * boundary between the (optional) language tag and code body.
+ */
+function hasFenceCodeContent(tail) {
+    if (!tail.startsWith("```"))
+        return false;
+    const after = tail.slice(3);
+    const nl = after.indexOf("\n");
+    if (nl < 0) {
+        // No newline yet — still on the language line. Nothing to close.
+        return false;
+    }
+    const code = after.slice(nl + 1);
+    return /\S/.test(code);
+}
+export function detectOpenContext(text) {
+    if (!text)
+        return { fenceLang: null, inlineCode: false, brackets: [] };
+    // ── Fence ────────────────────────────────────────────────────────
+    // Pair complete fences off the text; what remains tells us if a fence
+    // is still open and (if so) what its language tag is.
+    const paired = text.replace(/```[\s\S]*?```/g, "");
+    const openFenceIdx = paired.indexOf("```");
+    let fenceLang = null;
+    let remainder = paired;
+    if (openFenceIdx >= 0) {
+        // Everything from openFenceIdx onward is inside the open fence.
+        const tail = paired.slice(openFenceIdx);
+        const firstLine = tail.slice(3).split("\n", 1)[0] ?? "";
+        fenceLang = firstLine.trim();
+        remainder = paired.slice(0, openFenceIdx);
+    }
+    // ── Inline code (outside fences) ─────────────────────────────────
+    // Strip paired inline backticks; an odd remaining ` means open.
+    remainder = remainder.replace(/`[^`\n]+`/g, "");
+    const inlineCode = (remainder.match(/`/g) || []).length % 2 === 1;
+    // Cut at the last lone backtick — inside-inline content shouldn't
+    // contribute to bracket counting.
+    if (inlineCode) {
+        const lastBt = remainder.lastIndexOf("`");
+        if (lastBt >= 0)
+            remainder = remainder.slice(0, lastBt);
+    }
+    // ── Brackets (bold/italic/strike) ────────────────────────────────
+    const brackets = scanBracketStackForContext(remainder);
+    return { fenceLang, inlineCode, brackets };
+}
+/** Like scanBracketStack but exposed for context detection (no whitespace strip). */
+function scanBracketStackForContext(text) {
+    const stack = [];
+    const tryToggle = (m) => {
+        if (stack[stack.length - 1] === m)
+            stack.pop();
+        else
+            stack.push(m);
+    };
+    let i = 0;
+    while (i < text.length) {
+        if (text.startsWith("**", i)) {
+            tryToggle("**");
+            i += 2;
+        }
+        else if (text.startsWith("__", i)) {
+            tryToggle("__");
+            i += 2;
+        }
+        else if (text.startsWith("~~", i)) {
+            tryToggle("~~");
+            i += 2;
+        }
+        else if (text[i] === "*") {
+            tryToggle("*");
+            i += 1;
+        }
+        else if (text[i] === "_") {
+            tryToggle("_");
+            i += 1;
+        }
+        else {
+            i += 1;
+        }
+    }
+    return stack;
+}
+/**
+ * Render the opener prefix for a continuation chunk so it can stand on
+ * its own as a self-renderable markdown fragment. E.g. for an open
+ * `` ```python `` fence, returns ` ```python\n `; for an open `**` bold,
+ * returns `**`.
+ */
+export function renderContextOpener(ctx) {
+    // Fences are exclusive — if a fence is open, no other markers count
+    // (they're inside opaque code).
+    if (ctx.fenceLang !== null) {
+        return "```" + (ctx.fenceLang ?? "") + "\n";
+    }
+    let out = "";
+    for (const m of ctx.brackets)
+        out += m;
+    if (ctx.inlineCode)
+        out += "`";
+    return out;
+}