@copilotkit/channels-slack 0.1.0

package/dist/adapter.test.d.ts

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

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

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

package/dist/adapter.test.js

@@ -0,0 +1,368 @@
+import { describe, it, expect, vi } from "vitest";
+import { SlackAdapter } from "./adapter.js";
+/**
+ * Build an adapter with a mock Slack client injected. Constructing the real
+ * Bolt `App` is side-effect-free (Socket Mode doesn't connect until `start()`),
+ * but we never call `start()` here — every test drives the pure-ish egress and
+ * decode methods against a fake `client`.
+ */
+function makeAdapter() {
+    const chat = {
+        postMessage: vi.fn(async (_arg) => ({
+            ts: "200.5",
+            channel: "C1",
+        })),
+        update: vi.fn(async (_arg) => ({})),
+        delete: vi.fn(async (_arg) => ({})),
+    };
+    const adapter = new SlackAdapter({ botToken: "x", appToken: "y" });
+    adapter.client = { chat };
+    adapter.botUserId = "UBOT";
+    return { adapter, chat };
+}
+const section = (text) => ({
+    type: "section",
+    props: { children: [{ type: "text", props: { value: text } }] },
+});
+describe("SlackAdapter.post", () => {
+    it("posts blocks + fallback text to the target channel/thread and returns a MessageRef", async () => {
+        const { adapter, chat } = makeAdapter();
+        const ref = await adapter.post({ channel: "C1", threadTs: "100.0" }, [
+            section("hi"),
+        ]);
+        expect(chat.postMessage).toHaveBeenCalledTimes(1);
+        const arg = chat.postMessage.mock.calls[0][0];
+        expect(arg.channel).toBe("C1");
+        expect(arg.thread_ts).toBe("100.0");
+        expect(arg.text).toBe("hi");
+        expect(arg.blocks).toHaveLength(1);
+        expect(arg.blocks[0].type).toBe("section");
+        expect(arg.blocks.length).toBeLessThanOrEqual(50); // budget-clamped
+        expect(ref.id).toBe("200.5");
+        expect(ref.channel).toBe("C1");
+    });
+    it("renders a <Message accent> as a colored attachment with a short top-level text and NO fallback on the attachment", async () => {
+        const { adapter, chat } = makeAdapter();
+        const header = (text) => ({
+            type: "header",
+            props: { children: [{ type: "text", props: { value: text } }] },
+        });
+        await adapter.post({ channel: "C1" }, [
+            {
+                type: "message",
+                props: {
+                    accent: "#27AE60",
+                    children: [header("Open issues"), section("ok")],
+                },
+            },
+        ]);
+        const arg = chat.postMessage.mock.calls[0][0];
+        // Short top-level text (the notification/a11y summary) AND a colored
+        // attachment card with { color, blocks } — never a legacy `fallback` on
+        // the attachment (that triggers invalid_attachments). No top-level blocks.
+        expect(arg.text).toBe("Open issues");
+        expect(arg.blocks).toBeUndefined();
+        expect(arg.attachments).toHaveLength(1);
+        expect(arg.attachments[0].color).toBe("#27AE60");
+        expect(arg.attachments[0].blocks[0].type).toBe("header");
+        expect(arg.attachments[0].fallback).toBeUndefined();
+        // Unfurling is suppressed on the post.
+        expect(arg.unfurl_links).toBe(false);
+        expect(arg.unfurl_media).toBe(false);
+    });
+    it("defaults fallback text to … when the IR has no text", async () => {
+        const { adapter, chat } = makeAdapter();
+        await adapter.post({ channel: "C1" }, [{ type: "divider", props: {} }]);
+        const arg = chat.postMessage.mock.calls[0][0];
+        expect(arg.text).toBe("…");
+    });
+    it("uses the header as the short fallback summary — not a dump of the whole card", async () => {
+        const { adapter, chat } = makeAdapter();
+        const header = (text) => ({
+            type: "header",
+            props: { children: [{ type: "text", props: { value: text } }] },
+        });
+        await adapter.post({ channel: "C1" }, [
+            {
+                type: "message",
+                props: {
+                    accent: "#27AE60",
+                    children: [
+                        header("Open CPK issues"),
+                        section("CPK-1 Checkout 500s"),
+                        section("CPK-2 Login broken"),
+                    ],
+                },
+            },
+        ]);
+        const arg = chat.postMessage.mock.calls[0][0];
+        // The short summary is the header only — it must NOT concatenate the row text.
+        expect(arg.text).toBe("Open CPK issues");
+        expect(arg.text).not.toContain("CPK-1");
+    });
+});
+describe("SlackAdapter.update / delete use the stashed channel", () => {
+    it("update edits the message at ref.id on its channel", async () => {
+        const { adapter, chat } = makeAdapter();
+        await adapter.update({ id: "200.5", channel: "C1" }, [section("edited")]);
+        const arg = chat.update.mock.calls[0][0];
+        expect(arg.channel).toBe("C1");
+        expect(arg.ts).toBe("200.5");
+    });
+    it("update of an accent card sets a short top-level text and attachments with NO fallback", async () => {
+        const { adapter, chat } = makeAdapter();
+        const header = (text) => ({
+            type: "header",
+            props: { children: [{ type: "text", props: { value: text } }] },
+        });
+        await adapter.update({ id: "200.5", channel: "C1" }, [
+            {
+                type: "message",
+                props: { accent: "#EB5757", children: [header("Updated")] },
+            },
+        ]);
+        const arg = chat.update.mock.calls[0][0];
+        expect(arg.text).toBe("Updated");
+        expect(arg.blocks).toBeUndefined();
+        expect(arg.attachments[0].color).toBe("#EB5757");
+        expect(arg.attachments[0].fallback).toBeUndefined();
+    });
+    it("delete removes the message at ref.id on its channel", async () => {
+        const { adapter, chat } = makeAdapter();
+        await adapter.delete({ id: "200.5", channel: "C1" });
+        const arg = chat.delete.mock.calls[0][0];
+        expect(arg.channel).toBe("C1");
+        expect(arg.ts).toBe("200.5");
+    });
+});
+describe("SlackAdapter.decodeInteraction", () => {
+    it("decodes a block_actions payload to an opaque-id InteractionEvent", () => {
+        const { adapter } = makeAdapter();
+        const evt = adapter.decodeInteraction({
+            type: "block_actions",
+            channel: { id: "C1" },
+            message: { ts: "1", thread_ts: "100.0" },
+            actions: [{ action_id: "ck:z", value: '{"ok":1}' }],
+        });
+        expect(evt).toBeDefined();
+        expect(evt.id).toBe("ck:z");
+        expect(evt.value).toEqual({ ok: 1 });
+        expect(evt.conversationKey).toBe("C1::100.0");
+    });
+});
+describe("SlackAdapter.getMessages", () => {
+    it("maps conversations.replies to ThreadMessage[] (text/ts/isBot/resolved user)", async () => {
+        const { adapter } = makeAdapter();
+        const replies = vi.fn(async (_arg) => ({
+            messages: [
+                { ts: "100.0", text: "hello", user: "U1" },
+                { ts: "100.1", text: "bot reply", bot_id: "B1" },
+                { ts: "100.2", text: "joined", subtype: "channel_join", user: "U9" },
+            ],
+        }));
+        const info = vi.fn(async (_arg) => ({
+            user: { id: "U1", name: "ana", real_name: "Ana Smith" },
+        }));
+        adapter.client = {
+            conversations: { replies },
+            users: { info },
+        };
+        const msgs = await adapter.getMessages({
+            channel: "C1",
+            threadTs: "100.0",
+        });
+        expect(replies).toHaveBeenCalledTimes(1);
+        const arg = replies.mock.calls[0][0];
+        expect(arg.channel).toBe("C1");
+        expect(arg.ts).toBe("100.0");
+        // System (channel_join) subtype is skipped; the two real messages remain.
+        expect(msgs).toHaveLength(2);
+        expect(msgs[0]).toEqual({
+            text: "hello",
+            ts: "100.0",
+            isBot: false,
+            user: { id: "U1", name: "Ana Smith", email: undefined },
+        });
+        expect(msgs[1].isBot).toBe(true);
+        expect(msgs[1].text).toBe("bot reply");
+        expect(msgs[1].user).toBeUndefined();
+    });
+    it("returns [] for a flat target with no threadTs (nothing to fetch)", async () => {
+        const { adapter } = makeAdapter();
+        const replies = vi.fn();
+        adapter.client = {
+            conversations: { replies },
+        };
+        const msgs = await adapter.getMessages({ channel: "C1" });
+        expect(msgs).toEqual([]);
+        expect(replies).not.toHaveBeenCalled();
+    });
+    it("returns [] when conversations.replies throws", async () => {
+        const { adapter } = makeAdapter();
+        adapter.client = {
+            conversations: {
+                replies: vi.fn(async () => {
+                    throw new Error("rate_limited");
+                }),
+            },
+        };
+        const msgs = await adapter.getMessages({
+            channel: "C1",
+            threadTs: "100.0",
+        });
+        expect(msgs).toEqual([]);
+    });
+});
+describe("SlackAdapter.postFile", () => {
+    it("uploads via files.uploadV2 with channel_id/thread_ts/file and returns ok", async () => {
+        const { adapter } = makeAdapter();
+        const uploadV2 = vi.fn(async (_arg) => ({
+            ok: true,
+        }));
+        adapter.client = {
+            files: { uploadV2 },
+        };
+        const res = await adapter.postFile({ channel: "C1", threadTs: "100.0" }, {
+            bytes: new Uint8Array([1, 2, 3]),
+            filename: "chart.png",
+            title: "Chart",
+            altText: "alt",
+        });
+        expect(res).toEqual({ ok: true });
+        expect(uploadV2).toHaveBeenCalledTimes(1);
+        const arg = uploadV2.mock.calls[0][0];
+        expect(arg.channel_id).toBe("C1");
+        expect(arg.thread_ts).toBe("100.0");
+        expect(arg.filename).toBe("chart.png");
+        expect(arg.title).toBe("Chart");
+        expect(arg.alt_text).toBe("alt");
+        expect(Buffer.isBuffer(arg.file)).toBe(true);
+    });
+    it("omits thread_ts when the target has none", async () => {
+        const { adapter } = makeAdapter();
+        const uploadV2 = vi.fn(async (_arg) => ({
+            ok: true,
+        }));
+        adapter.client = {
+            files: { uploadV2 },
+        };
+        await adapter.postFile({ channel: "C1" }, { bytes: new Uint8Array([1]), filename: "x.png" });
+        const arg = uploadV2.mock.calls[0][0];
+        expect(arg.thread_ts).toBeUndefined();
+    });
+    it("returns ok:false with the error message when uploadV2 throws", async () => {
+        const { adapter } = makeAdapter();
+        const uploadV2 = vi.fn(async () => {
+            throw new Error("upload_failed");
+        });
+        adapter.client = {
+            files: { uploadV2 },
+        };
+        const res = await adapter.postFile({ channel: "C1" }, { bytes: new Uint8Array([1]), filename: "x.png" });
+        expect(res).toEqual({ ok: false, error: "upload_failed" });
+    });
+});
+describe("SlackAdapter.capabilities / ackDeadlineMs", () => {
+    it("reports the Slack surface capabilities", () => {
+        const { adapter } = makeAdapter();
+        expect(adapter.capabilities.supportsTyping).toBe(false);
+        expect(adapter.capabilities.supportsStreaming).toBe(true);
+        expect(adapter.capabilities.maxBlocksPerMessage).toBe(50);
+        expect(adapter.ackDeadlineMs).toBe(3000);
+        expect(adapter.platform).toBe("slack");
+    });
+});
+describe("SlackAdapter.resolveUser", () => {
+    it("resolves a sender id to a richer PlatformUser (name + email) and caches it", async () => {
+        const { adapter } = makeAdapter();
+        const info = vi.fn(async (_arg) => ({
+            user: {
+                id: "U1",
+                name: "ana",
+                real_name: "Ana Smith",
+                profile: { real_name: "Ana Smith", email: "ana@example.com" },
+            },
+        }));
+        adapter.client = {
+            users: { info },
+        };
+        const u = await adapter.resolveUser("U1");
+        expect(u).toEqual({
+            id: "U1",
+            name: "Ana Smith",
+            email: "ana@example.com",
+        });
+        // Second call is served from cache (no extra users.info call).
+        const u2 = await adapter.resolveUser("U1");
+        expect(u2).toEqual(u);
+        expect(info).toHaveBeenCalledTimes(1);
+    });
+    it("falls back to a bare { id } when users.info fails", async () => {
+        const { adapter } = makeAdapter();
+        const info = vi.fn(async () => {
+            throw new Error("not_found");
+        });
+        adapter.client = {
+            users: { info },
+        };
+        const u = await adapter.resolveUser("U2");
+        expect(u).toEqual({ id: "U2" });
+    });
+});
+describe("SlackAdapter action wiring", () => {
+    it("decodes a captured block_actions body and forwards to sink.onInteraction", async () => {
+        const { adapter } = makeAdapter();
+        // Capture the handler Bolt would register, without starting sockets.
+        let actionHandler;
+        const app = {
+            action: vi.fn((_matcher, handler) => {
+                actionHandler = handler;
+            }),
+            init: vi.fn(async () => { }),
+            start: vi.fn(async () => { }),
+        };
+        adapter.app = app;
+        // auth.test is awaited in start(); attachSlackListener reads app.event etc.
+        adapter.client = {
+            ...adapter.client,
+            auth: { test: vi.fn(async () => ({ user_id: "UBOT" })) },
+        };
+        // attachSlackListener calls app.command/event/message and (default-on)
+        // attachAssistant calls app.assistant — stub them.
+        Object.assign(app, {
+            command: vi.fn(),
+            event: vi.fn(),
+            message: vi.fn(),
+            assistant: vi.fn(),
+            view: vi.fn(),
+        });
+        const received = [];
+        const sink = {
+            onTurn: vi.fn(),
+            onInteraction: (evt) => {
+                received.push(evt);
+            },
+            onCommand: vi.fn(),
+            onThreadStarted: vi.fn(),
+            onReaction: vi.fn(),
+            onModalSubmit: vi.fn(async () => { }),
+            onModalClose: vi.fn(),
+        };
+        await adapter.start(sink);
+        expect(actionHandler).toBeDefined();
+        const ack = vi.fn(async () => { });
+        await actionHandler({
+            ack,
+            body: {
+                type: "block_actions",
+                channel: { id: "C1" },
+                message: { ts: "1", thread_ts: "100.0" },
+                actions: [{ action_id: "ck:z", value: '{"ok":1}' }],
+            },
+        });
+        expect(ack).toHaveBeenCalledTimes(1);
+        expect(received).toHaveLength(1);
+        expect(received[0].id).toBe("ck:z");
+        expect(received[0].conversationKey).toBe("C1::100.0");
+    });
+});

package/dist/assistant.d.ts

@@ -0,0 +1,19 @@
+import type { App } from "@slack/bolt";
+import type { IngressSink, PlatformUser } from "@copilotkit/channels";
+import type { SlackAssistantOptions } from "./types.js";
+export interface AttachAssistantConfig {
+    app: App;
+    /** The engine sink — pane events are delivered straight to it. */
+    sink: IngressSink;
+    /** Static pane behavior (greeting / prompts / title). */
+    opts: SlackAssistantOptions;
+    /** Resolve a Slack user id to a richer PlatformUser (adapter-owned, cached). */
+    resolveUser: (userId: string) => Promise<PlatformUser>;
+}
+export interface AssistantHandle {
+    /** True if `(channel, threadTs)` is a known assistant-pane thread. */
+    isAssistantThread: (channel: string, threadTs: string) => boolean;
+}
+/** Register the Bolt `Assistant` middleware and bridge it to the engine sink. */
+export declare function attachAssistant(cfg: AttachAssistantConfig): AssistantHandle;
+//# sourceMappingURL=assistant.d.ts.map

package/dist/assistant.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assistant.d.ts","sourceRoot":"","sources":["../src/assistant.ts"],"names":[],"mappings":"AAsBA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,aAAa,CAAC;AACvC,OAAO,KAAK,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAEtE,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAExD,MAAM,WAAW,qBAAqB;IACpC,GAAG,EAAE,GAAG,CAAC;IACT,kEAAkE;IAClE,IAAI,EAAE,WAAW,CAAC;IAClB,yDAAyD;IACzD,IAAI,EAAE,qBAAqB,CAAC;IAC5B,gFAAgF;IAChF,WAAW,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,YAAY,CAAC,CAAC;CACxD;AAED,MAAM,WAAW,eAAe;IAC9B,sEAAsE;IACtE,iBAAiB,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC;CACnE;AAED,iFAAiF;AACjF,wBAAgB,eAAe,CAAC,GAAG,EAAE,qBAAqB,GAAG,eAAe,CAiH3E"}

package/dist/assistant.js

@@ -0,0 +1,124 @@
+/**
+ * Slack assistant-pane wiring — the SOLE owner of pane (`assistant_thread_*`)
+ * events. Bridges Bolt's `Assistant` middleware to the engine `IngressSink`.
+ *
+ * Flow:
+ *   - `assistant_thread_started` → apply the adapter's STATIC defaults first
+ *     (greeting + suggested prompts), then emit `sink.onThreadStarted` so
+ *     `bot.onThreadStarted` handlers layer on top (never race the defaults).
+ *     Records the pane thread so the message listener's guard can skip it.
+ *   - a user message in the pane → exactly ONE `sink.onTurn`, scoped to the
+ *     pane thread's `ts` (`channelId::threadTs`, NOT the flat DM scope), with a
+ *     threaded reply target carrying `recipientUserId` (native streaming needs
+ *     it). First message + `title: "auto"` → `assistant.threads.setTitle`.
+ *   - `assistant_thread_context_changed` → persisted via Bolt's default
+ *     thread-context store (stored for a later release; not yet fed to the agent).
+ *
+ * Pane messages arrive as threaded `message.im` events, which the ordinary
+ * `app.message` listener also sees; `attachSlackListener` is given the
+ * `isAssistantThread` predicate returned here so each pane message becomes
+ * exactly one turn (see slack-listener.ts).
+ */
+import { Assistant } from "@slack/bolt";
+import { conversationKeyOf } from "./interaction.js";
+/** Register the Bolt `Assistant` middleware and bridge it to the engine sink. */
+export function attachAssistant(cfg) {
+    const { app, sink, opts, resolveUser } = cfg;
+    // Pane threads seen this process (channelId::threadTs). Populated on
+    // thread_started and (defensively, after a restart) on the first message.
+    const assistantThreads = new Set();
+    // Threads we've already auto-titled, so only the FIRST user message titles.
+    const titled = new Set();
+    const titleAuto = opts.title !== false; // default "auto"
+    const assistant = new Assistant({
+        threadStarted: async ({ event, say, setSuggestedPrompts }) => {
+            const at = event
+                .assistant_thread;
+            if (!at?.channel_id || !at.thread_ts)
+                return;
+            const channelId = at.channel_id;
+            const threadTs = at.thread_ts;
+            assistantThreads.add(threadKey(channelId, threadTs));
+            // ── Static defaults first (greeting + prompts). Degrade, never throw. ──
+            if (opts.greeting) {
+                try {
+                    await say(opts.greeting);
+                }
+                catch (err) {
+                    console.error("[slack-assistant] greeting failed:", err);
+                }
+            }
+            if (opts.suggestedPrompts && opts.suggestedPrompts.length > 0) {
+                try {
+                    await setSuggestedPrompts({
+                        prompts: opts.suggestedPrompts.map((p) => ({
+                            title: p.title,
+                            message: p.message,
+                        })),
+                    });
+                }
+                catch (err) {
+                    console.error("[slack-assistant] setSuggestedPrompts failed:", err);
+                }
+            }
+            // ── Then hand off to the engine (onThreadStarted handlers layer on top). ──
+            const user = at.user_id ? await resolveUser(at.user_id) : undefined;
+            await sink.onThreadStarted({
+                conversationKey: conversationKeyOf({ channelId, scope: threadTs }),
+                replyTarget: {
+                    channel: channelId,
+                    threadTs,
+                    recipientUserId: at.user_id,
+                },
+                user,
+                platform: "slack",
+            });
+        },
+        userMessage: async ({ message, setTitle }) => {
+            const m = message;
+            // Pane messages are always threaded; ignore anything without a thread.
+            if (!m.channel || !m.thread_ts)
+                return;
+            const channelId = m.channel;
+            const threadTs = m.thread_ts;
+            const key = conversationKeyOf({ channelId, scope: threadTs });
+            assistantThreads.add(threadKey(channelId, threadTs)); // defensive (post-restart)
+            const text = (m.text ?? "").trim();
+            // Auto-title from the first user message.
+            if (titleAuto && !titled.has(key)) {
+                titled.add(key);
+                const title = text.replace(/\s+/g, " ").slice(0, 80);
+                if (title) {
+                    try {
+                        await setTitle(title);
+                    }
+                    catch (err) {
+                        console.error("[slack-assistant] setTitle failed:", err);
+                    }
+                }
+            }
+            await sink.onTurn({
+                conversationKey: key,
+                replyTarget: { channel: channelId, threadTs, recipientUserId: m.user },
+                userText: text,
+                user: m.user ? await resolveUser(m.user) : undefined,
+                platform: "slack",
+            });
+        },
+        threadContextChanged: async ({ saveThreadContext }) => {
+            // Persist via Bolt's default thread-context store. Stored for a later
+            // release; not yet consumed by the agent.
+            try {
+                await saveThreadContext();
+            }
+            catch (err) {
+                console.error("[slack-assistant] saveThreadContext failed:", err);
+            }
+        },
+    });
+    app.assistant(assistant);
+    return {
+        isAssistantThread: (channel, threadTs) => assistantThreads.has(threadKey(channel, threadTs)),
+    };
+}
+const threadKey = (channel, threadTs) => `${channel}::${threadTs}`;

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

@@ -0,0 +1,62 @@
+/**
+ * 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 Slack,
+ * the rest of the message renders broken (a stray ``` will turn the rest
+ * of the Slack 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 Slack message.
+ *
+ * Operates in **markdown space** (i.e. on the raw text from the agent,
+ * before mrkdwn translation). The caller composes this with
+ * `markdownToMrkdwn` afterwards so the translator sees a balanced
+ * document.
+ *
+ * What it handles, in priority order:
+ *
+ *   1. Unclosed fenced code blocks ``` … (most severe — leaks code styling
+ *      through the rest of the Slack 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 Slack messages mid-formatting
+ * — without this, a chunk boundary inside a ` ```python … ``` ` block
+ * would have the second Slack message start with raw code that Slack
+ * 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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AAKH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CA+E1D;AAgFD;;;;;;;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"}