@copilotkit/channels-slack 0.1.0

package/dist/render/block-kit.test.js

@@ -0,0 +1,289 @@
+import { Header, Message, Section, renderToIR } from "@copilotkit/channels-ui";
+import { describe, expect, it } from "vitest";
+import { renderBlockKit, renderSlackMessage } from "./block-kit.js";
+describe("renderBlockKit", () => {
+    it("flattens a message into header + section blocks (markdown → mrkdwn)", () => {
+        const ir = renderToIR(Message({
+            children: [
+                Header({ children: "Hi" }),
+                Section({ children: "**bold**" }),
+            ],
+        }));
+        expect(renderBlockKit(ir)).toEqual([
+            { type: "header", text: { type: "plain_text", text: "Hi" } },
+            { type: "section", text: { type: "mrkdwn", text: "*bold*" } },
+        ]);
+    });
+    it("renders a pre-bound button inside actions with its stamped action_id", () => {
+        const ir = [
+            {
+                type: "actions",
+                props: {
+                    children: [
+                        {
+                            type: "button",
+                            props: {
+                                onClick: { id: "ck:abc" },
+                                value: { confirmed: true },
+                                style: "primary",
+                                children: [{ type: "text", props: { value: "Create" } }],
+                            },
+                        },
+                    ],
+                },
+            },
+        ];
+        expect(renderBlockKit(ir)).toEqual([
+            {
+                type: "actions",
+                elements: [
+                    {
+                        type: "button",
+                        action_id: "ck:abc",
+                        text: { type: "plain_text", text: "Create" },
+                        value: '{"confirmed":true}',
+                        style: "primary",
+                    },
+                ],
+            },
+        ]);
+    });
+    it("renders a divider", () => {
+        expect(renderBlockKit([{ type: "divider", props: {} }])).toEqual([
+            { type: "divider" },
+        ]);
+    });
+    it("applies the section text budget (≤3000, trailing ellipsis)", () => {
+        const blocks = renderBlockKit(renderToIR(Section({ children: "x".repeat(4000) })));
+        const section = blocks[0];
+        expect(section.text.text.length).toBeLessThanOrEqual(3000);
+        expect(section.text.text.endsWith("…")).toBe(true);
+    });
+    it("renders an input block with its stamped action_id", () => {
+        expect(renderBlockKit([
+            {
+                type: "input",
+                props: {
+                    onSubmit: { id: "ck:in1" },
+                    placeholder: "Name",
+                    multiline: false,
+                },
+            },
+        ])).toEqual([
+            {
+                type: "input",
+                dispatch_action: true,
+                element: {
+                    type: "plain_text_input",
+                    action_id: "ck:in1",
+                    multiline: false,
+                },
+                label: { type: "plain_text", text: "Name" },
+            },
+        ]);
+    });
+    it("gives a static_select a fallback action_id when onSelect is absent", () => {
+        const blocks = renderBlockKit([
+            {
+                type: "actions",
+                props: {
+                    children: [
+                        {
+                            type: "select",
+                            props: { options: [{ label: "A", value: "a" }] },
+                        },
+                    ],
+                },
+            },
+        ]);
+        const select = blocks[0]
+            .elements[0];
+        expect(select.action_id).toBe("select");
+        expect(select.action_id.length).toBeGreaterThan(0);
+    });
+    it("renders a Table IR into a native Slack table block", () => {
+        const ir = [
+            {
+                type: "table",
+                props: {
+                    columns: [{ header: "Name" }, { header: "Status", align: "center" }],
+                    children: [
+                        {
+                            type: "row",
+                            props: {
+                                children: [
+                                    {
+                                        type: "cell",
+                                        props: {
+                                            children: [{ type: "text", props: { value: "Ana" } }],
+                                        },
+                                    },
+                                    {
+                                        type: "cell",
+                                        props: {
+                                            children: [{ type: "text", props: { value: "Active" } }],
+                                        },
+                                    },
+                                ],
+                            },
+                        },
+                    ],
+                },
+            },
+        ];
+        expect(renderBlockKit(ir)).toEqual([
+            {
+                type: "table",
+                rows: [
+                    [
+                        { type: "raw_text", text: "Name" },
+                        { type: "raw_text", text: "Status" },
+                    ],
+                    [
+                        { type: "raw_text", text: "Ana" },
+                        { type: "raw_text", text: "Active" },
+                    ],
+                ],
+                column_settings: [{ align: "left" }, { align: "center" }],
+            },
+        ]);
+    });
+    it("passes raw native Block Kit through unchanged", () => {
+        expect(renderBlockKit([
+            {
+                type: "raw",
+                props: {
+                    value: [
+                        { type: "section", text: { type: "mrkdwn", text: "native" } },
+                    ],
+                },
+            },
+        ])).toEqual([{ type: "section", text: { type: "mrkdwn", text: "native" } }]);
+    });
+    it("renders a link button with a url", () => {
+        const blocks = renderBlockKit([
+            {
+                type: "actions",
+                props: {
+                    children: [
+                        {
+                            type: "button",
+                            props: {
+                                url: "https://dash/deploy/42",
+                                children: [{ type: "text", props: { value: "Open" } }],
+                            },
+                        },
+                    ],
+                },
+            },
+        ]);
+        const el = blocks[0].elements[0];
+        expect(el.url).toBe("https://dash/deploy/42");
+    });
+    it("renders a Field label as a bold mrkdwn line above the value", () => {
+        const blocks = renderBlockKit([
+            {
+                type: "field",
+                props: {
+                    label: "Status",
+                    children: [{ type: "text", props: { value: "Online" } }],
+                },
+            },
+        ]);
+        const text = blocks[0].fields[0].text;
+        expect(text).toBe("*Status*\nOnline");
+    });
+    it("renders a multi-select as its own input block, not inside actions", () => {
+        const blocks = renderBlockKit([
+            {
+                type: "actions",
+                props: {
+                    children: [
+                        {
+                            type: "select",
+                            props: {
+                                multi: true,
+                                onSelect: { id: "ck:ms" },
+                                placeholder: "Pick teams",
+                                options: [
+                                    { label: "Core", value: "core" },
+                                    { label: "Infra", value: "infra" },
+                                ],
+                            },
+                        },
+                    ],
+                },
+            },
+        ]);
+        // No actions block is emitted (the only child was peeled into an input block).
+        expect(blocks).toHaveLength(1);
+        const block = blocks[0];
+        expect(block.type).toBe("input");
+        expect(block.dispatch_action).toBe(true);
+        expect(block.element.type).toBe("multi_static_select");
+        expect(block.element.action_id).toBe("ck:ms");
+    });
+    it("keeps source order when a multi-select is mixed with a button", () => {
+        const blocks = renderBlockKit([
+            {
+                type: "actions",
+                props: {
+                    children: [
+                        {
+                            type: "button",
+                            props: {
+                                onClick: { id: "ck:b" },
+                                children: [{ type: "text", props: { value: "Go" } }],
+                            },
+                        },
+                        {
+                            type: "select",
+                            props: {
+                                multi: true,
+                                onSelect: { id: "ck:ms" },
+                                options: [{ label: "Core", value: "core" }],
+                            },
+                        },
+                    ],
+                },
+            },
+        ]);
+        // The button's actions block comes first, then the multi-select input block.
+        expect(blocks.map((b) => b.type)).toEqual([
+            "actions",
+            "input",
+        ]);
+    });
+});
+describe("renderSlackMessage", () => {
+    it("extracts a top-level <Message accent> as the attachment color", () => {
+        expect(renderSlackMessage([
+            {
+                type: "message",
+                props: {
+                    accent: "#EB5757",
+                    children: [
+                        {
+                            type: "section",
+                            props: { children: [{ type: "text", props: { value: "hi" } }] },
+                        },
+                    ],
+                },
+            },
+        ])).toEqual({
+            blocks: [{ type: "section", text: { type: "mrkdwn", text: "hi" } }],
+            accent: "#EB5757",
+        });
+    });
+    it("returns no accent when there is no message wrapper", () => {
+        expect(renderSlackMessage([
+            {
+                type: "section",
+                props: { children: [{ type: "text", props: { value: "hi" } }] },
+            },
+        ])).toEqual({
+            blocks: [{ type: "section", text: { type: "mrkdwn", text: "hi" } }],
+            accent: undefined,
+        });
+    });
+});

package/dist/render/budget.d.ts

@@ -0,0 +1,24 @@
+export declare const SLACK_LIMITS: {
+    readonly blocksPerMessage: 50;
+    readonly sectionText: 3000;
+    readonly headerText: 150;
+    readonly fieldsPerSection: 10;
+    readonly fieldText: 2000;
+    readonly actionsElements: 25;
+    readonly contextElements: 10;
+    readonly buttonText: 75;
+    readonly actionId: 255;
+    readonly buttonValue: 2000;
+    readonly selectOptions: 100;
+    readonly tableColumns: 20;
+    readonly tableRows: 100;
+    readonly cellText: 2000;
+};
+/** Truncate to max chars, appending an ellipsis marker if the input was longer. Never returns >max. */
+export declare function truncateText(text: string, max: number): string;
+/** Clamp an array to max items; return the kept items plus how many overflowed (for an overflow signal). */
+export declare function clampArray<T>(items: readonly T[], max: number): {
+    items: T[];
+    overflow: number;
+};
+//# sourceMappingURL=budget.d.ts.map

package/dist/render/budget.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"budget.d.ts","sourceRoot":"","sources":["../../src/render/budget.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;CAef,CAAC;AAEX,uGAAuG;AACvG,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAI9D;AAED,4GAA4G;AAC5G,wBAAgB,UAAU,CAAC,CAAC,EAC1B,KAAK,EAAE,SAAS,CAAC,EAAE,EACnB,GAAG,EAAE,MAAM,GACV;IAAE,KAAK,EAAE,CAAC,EAAE,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAGlC"}

package/dist/render/budget.js

@@ -0,0 +1,30 @@
+export const SLACK_LIMITS = {
+    blocksPerMessage: 50,
+    sectionText: 3000,
+    headerText: 150,
+    fieldsPerSection: 10,
+    fieldText: 2000,
+    actionsElements: 25,
+    contextElements: 10,
+    buttonText: 75,
+    actionId: 255,
+    buttonValue: 2000,
+    selectOptions: 100,
+    tableColumns: 20,
+    tableRows: 100,
+    cellText: 2000,
+};
+/** Truncate to max chars, appending an ellipsis marker if the input was longer. Never returns >max. */
+export function truncateText(text, max) {
+    if (text.length <= max)
+        return text;
+    if (max <= 1)
+        return text.slice(0, max);
+    return text.slice(0, max - 1) + "…"; // …
+}
+/** Clamp an array to max items; return the kept items plus how many overflowed (for an overflow signal). */
+export function clampArray(items, max) {
+    if (items.length <= max)
+        return { items: [...items], overflow: 0 };
+    return { items: items.slice(0, max), overflow: items.length - max };
+}

package/dist/render/budget.test.d.ts

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

package/dist/render/budget.test.d.ts.map

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

package/dist/render/budget.test.js

@@ -0,0 +1,49 @@
+import { describe, it, expect } from "vitest";
+import { SLACK_LIMITS, truncateText, clampArray } from "./budget.js";
+describe("budget: truncateText", () => {
+    it("leaves short text unchanged", () => {
+        expect(truncateText("hello", 3000)).toBe("hello");
+    });
+    it("truncates section text to 3000 chars with an ellipsis", () => {
+        const long = "x".repeat(4000);
+        const out = truncateText(long, SLACK_LIMITS.sectionText);
+        expect(out.length).toBe(3000);
+        expect(out.endsWith("…")).toBe(true);
+    });
+    it("truncates button text to 75 and action_id to 255", () => {
+        expect(truncateText("y".repeat(200), SLACK_LIMITS.buttonText).length).toBe(75);
+        expect(truncateText("z".repeat(500), SLACK_LIMITS.actionId).length).toBe(255);
+    });
+    it("truncates field text to 2000 and button value to 2000", () => {
+        expect(truncateText("a".repeat(5000), SLACK_LIMITS.fieldText).length).toBe(2000);
+        expect(truncateText("b".repeat(5000), SLACK_LIMITS.buttonValue).length).toBe(2000);
+    });
+});
+describe("budget: clampArray", () => {
+    it("keeps arrays within the limit untouched (overflow 0)", () => {
+        expect(clampArray([1, 2, 3], 25)).toEqual({
+            items: [1, 2, 3],
+            overflow: 0,
+        });
+    });
+    it("clamps actions to 25 elements and reports overflow", () => {
+        const els = Array.from({ length: 30 }, (_, i) => i);
+        const r = clampArray(els, SLACK_LIMITS.actionsElements);
+        expect(r.items.length).toBe(25);
+        expect(r.overflow).toBe(5);
+    });
+    it("clamps context to 10, fields to 10, blocks to 50, select options to 100", () => {
+        expect(clampArray(Array(20).fill(0), SLACK_LIMITS.contextElements).items.length).toBe(10);
+        expect(clampArray(Array(15).fill(0), SLACK_LIMITS.fieldsPerSection).items.length).toBe(10);
+        expect(clampArray(Array(60).fill(0), SLACK_LIMITS.blocksPerMessage).items.length).toBe(50);
+        expect(clampArray(Array(150).fill(0), SLACK_LIMITS.selectOptions).items.length).toBe(100);
+    });
+    it("clamps table columns to 20 and table rows to 100", () => {
+        const cols = clampArray(Array(30).fill(0), SLACK_LIMITS.tableColumns);
+        expect(cols.items.length).toBe(20);
+        expect(cols.overflow).toBe(10);
+        const rows = clampArray(Array(150).fill(0), SLACK_LIMITS.tableRows);
+        expect(rows.items.length).toBe(100);
+        expect(rows.overflow).toBe(50);
+    });
+});

package/dist/render/modal.d.ts

@@ -0,0 +1,13 @@
+import type { BotNode } from "@copilotkit/channels-ui";
+import type { View } from "@slack/web-api";
+/**
+ * Render a modal IR tree (a `<Modal>` root with `modal_text_input` /
+ * `modal_select` / `modal_radio` children) into a Slack `views.open` `View`.
+ *
+ * Each field's `id` becomes both the block `block_id` and the element
+ * `action_id`, so a `view_submission`'s `state.values[id][id]` maps straight
+ * back to the field. Throws {@link ModalRenderError} when there is no modal
+ * root or a child uses an unsupported element type.
+ */
+export declare function renderSlackModal(ir: BotNode[]): View;
+//# sourceMappingURL=modal.d.ts.map

package/dist/render/modal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"modal.d.ts","sourceRoot":"","sources":["../../src/render/modal.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,yBAAyB,CAAC;AAEvD,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAC;AAkB3C;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,OAAO,EAAE,GAAG,IAAI,CA0FpD"}

package/dist/render/modal.js

@@ -0,0 +1,108 @@
+import { ModalRenderError } from "@copilotkit/channels-ui";
+const plain = (text) => ({ type: "plain_text", text });
+function optionFrom(node) {
+    return {
+        text: plain(String(node.props.label ?? "")),
+        value: String(node.props.value ?? ""),
+    };
+}
+function childOptions(node) {
+    const kids = node.props.children;
+    return Array.isArray(kids)
+        ? kids.filter((k) => k.type === "modal_select_option")
+        : [];
+}
+/**
+ * Render a modal IR tree (a `<Modal>` root with `modal_text_input` /
+ * `modal_select` / `modal_radio` children) into a Slack `views.open` `View`.
+ *
+ * Each field's `id` becomes both the block `block_id` and the element
+ * `action_id`, so a `view_submission`'s `state.values[id][id]` maps straight
+ * back to the field. Throws {@link ModalRenderError} when there is no modal
+ * root or a child uses an unsupported element type.
+ */
+export function renderSlackModal(ir) {
+    const root = ir.find((n) => n.type === "modal");
+    if (!root)
+        throw new ModalRenderError("renderSlackModal: no <Modal> root in IR");
+    const p = root.props;
+    const kids = Array.isArray(p.children) ? p.children : [];
+    const blocks = kids.map((node) => {
+        const fp = node.props;
+        const id = String(fp.id ?? "");
+        const label = plain(String(fp.label ?? ""));
+        const optional = fp.optional === true;
+        switch (node.type) {
+            case "modal_text_input":
+                return {
+                    type: "input",
+                    block_id: id,
+                    label,
+                    optional,
+                    element: {
+                        type: "plain_text_input",
+                        action_id: id,
+                        ...(fp.multiline ? { multiline: true } : {}),
+                        ...(fp.placeholder
+                            ? { placeholder: plain(String(fp.placeholder)) }
+                            : {}),
+                        ...(fp.initialValue
+                            ? { initial_value: String(fp.initialValue) }
+                            : {}),
+                        ...(fp.maxLength ? { max_length: Number(fp.maxLength) } : {}),
+                    },
+                };
+            case "modal_select": {
+                const options = childOptions(node).map(optionFrom);
+                const init = options.find((o) => o.value === String(fp.initialOption ?? ""));
+                return {
+                    type: "input",
+                    block_id: id,
+                    label,
+                    optional,
+                    element: {
+                        type: "static_select",
+                        action_id: id,
+                        options,
+                        ...(fp.placeholder
+                            ? { placeholder: plain(String(fp.placeholder)) }
+                            : {}),
+                        ...(init ? { initial_option: init } : {}),
+                    },
+                };
+            }
+            case "modal_radio": {
+                const options = childOptions(node).map(optionFrom);
+                const init = options.find((o) => o.value === String(fp.initialOption ?? ""));
+                return {
+                    type: "input",
+                    block_id: id,
+                    label,
+                    optional,
+                    element: {
+                        type: "radio_buttons",
+                        action_id: id,
+                        options,
+                        ...(init ? { initial_option: init } : {}),
+                    },
+                };
+            }
+            default:
+                throw new ModalRenderError(`renderSlackModal: unsupported modal element "${String(node.type)}"`);
+        }
+    });
+    return {
+        type: "modal",
+        callback_id: String(p.callbackId ?? ""),
+        title: plain(String(p.title ?? "")),
+        ...(p.submitLabel
+            ? { submit: plain(String(p.submitLabel)) }
+            : { submit: plain("Submit") }),
+        ...(p.closeLabel ? { close: plain(String(p.closeLabel)) } : {}),
+        ...(p.notifyOnClose ? { notify_on_close: true } : {}),
+        ...(p.privateMetadata
+            ? { private_metadata: String(p.privateMetadata) }
+            : {}),
+        blocks: blocks,
+    };
+}

package/dist/render/transport.d.ts

@@ -0,0 +1,42 @@
+/**
+ * The credentialed Slack side-effects the run renderer performs, injected so
+ * {@link createRunRenderer} (event-renderer.ts) stays free of `@slack/web-api`
+ * (no `WebClient`, no Bolt). The native Slack adapter wraps a real `WebClient`;
+ * the managed Connector Outbox wraps its own credentialed sender — both drive
+ * the exact same renderer.
+ *
+ * These are the three ops the renderer calls directly. The four native
+ * streaming ops (`chat.startStream`/`appendStream`/`stopStream`) are injected
+ * separately as a {@link NativeStreamTransport} (native-stream.ts).
+ */
+export interface SlackRenderTransport {
+    /**
+     * `assistant.threads.setStatus` — the thread-anchored "is thinking…" /
+     * "is using `tool`…" indicator. Passing an empty `status` clears it.
+     */
+    setStatus(args: {
+        channel_id: string;
+        thread_ts: string;
+        status: string;
+        loading_messages?: string[];
+    }): Promise<void>;
+    /**
+     * `chat.postMessage` — post a message (streaming placeholder, `:wrench:`
+     * tool-status row, or error notice). Resolves with the new message `ts`; the
+     * legacy text stream treats a missing `ts` as a hard failure.
+     */
+    postMessage(args: {
+        channel: string;
+        thread_ts?: string;
+        text: string;
+    }): Promise<{
+        ts?: string;
+    }>;
+    /** `chat.update` — edit an existing message in place. */
+    updateMessage(args: {
+        channel: string;
+        ts: string;
+        text: string;
+    }): Promise<void>;
+}
+//# sourceMappingURL=transport.d.ts.map

package/dist/render/transport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transport.d.ts","sourceRoot":"","sources":["../../src/render/transport.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,MAAM,WAAW,oBAAoB;IACnC;;;OAGG;IACH,SAAS,CAAC,IAAI,EAAE;QACd,UAAU,EAAE,MAAM,CAAC;QACnB,SAAS,EAAE,MAAM,CAAC;QAClB,MAAM,EAAE,MAAM,CAAC;QACf,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAC;KAC7B,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAClB;;;;OAIG;IACH,WAAW,CAAC,IAAI,EAAE;QAChB,OAAO,EAAE,MAAM,CAAC;QAChB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,IAAI,EAAE,MAAM,CAAC;KACd,GAAG,OAAO,CAAC;QAAE,EAAE,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC7B,yDAAyD;IACzD,aAAa,CAAC,IAAI,EAAE;QAClB,OAAO,EAAE,MAAM,CAAC;QAChB,EAAE,EAAE,MAAM,CAAC;QACX,IAAI,EAAE,MAAM,CAAC;KACd,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACnB"}

package/dist/render/transport.js

@@ -0,0 +1 @@
+export {};

package/dist/render.d.ts

@@ -0,0 +1,23 @@
+/**
+ * `@copilotkit/channels-slack/render` — the pure, Bolt-free Slack rendering surface.
+ *
+ * Nothing here imports `@slack/bolt` or instantiates a `WebClient`: the
+ * stateful run renderer takes its credentialed side-effects as injected
+ * transports ({@link SlackRenderTransport} + {@link NativeStreamTransport}), and
+ * the IR→Block Kit / modal / mrkdwn helpers are pure functions. This is the
+ * seam the native Slack adapter AND the managed Connector Outbox both consume,
+ * so managed replies reach 1:1 UX parity with the native bot without forking
+ * the renderer.
+ */
+export { createRunRenderer } from "./event-renderer.js";
+export type { SlackRenderTransport } from "./render/transport.js";
+export { renderBlockKit, renderSlackMessage, buildFeedbackBlocks, FEEDBACK_ACTION_ID, } from "./render/block-kit.js";
+export { renderSlackModal } from "./render/modal.js";
+export { SLACK_LIMITS } from "./render/budget.js";
+export { NativeMessageStream } from "./native-stream.js";
+export { ChunkedMessageStream } from "./chunked-message-stream.js";
+export { MessageStream } from "./message-stream.js";
+export type { NativeMessageStreamConfig, NativeStreamTransport, TextStream, } from "./native-stream.js";
+export { markdownToMrkdwn } from "./markdown-to-mrkdwn.js";
+export { autoCloseOpenMarkdown } from "./auto-close-streaming.js";
+//# sourceMappingURL=render.d.ts.map

package/dist/render.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"render.d.ts","sourceRoot":"","sources":["../src/render.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AACxD,YAAY,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAC;AAElE,OAAO,EACL,cAAc,EACd,kBAAkB,EAClB,mBAAmB,EACnB,kBAAkB,GACnB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAElD,OAAO,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AACzD,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AACnE,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,YAAY,EACV,yBAAyB,EACzB,qBAAqB,EACrB,UAAU,GACX,MAAM,oBAAoB,CAAC;AAE5B,OAAO,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAC3D,OAAO,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAC"}

package/dist/render.js

@@ -0,0 +1,20 @@
+/**
+ * `@copilotkit/channels-slack/render` — the pure, Bolt-free Slack rendering surface.
+ *
+ * Nothing here imports `@slack/bolt` or instantiates a `WebClient`: the
+ * stateful run renderer takes its credentialed side-effects as injected
+ * transports ({@link SlackRenderTransport} + {@link NativeStreamTransport}), and
+ * the IR→Block Kit / modal / mrkdwn helpers are pure functions. This is the
+ * seam the native Slack adapter AND the managed Connector Outbox both consume,
+ * so managed replies reach 1:1 UX parity with the native bot without forking
+ * the renderer.
+ */
+export { createRunRenderer } from "./event-renderer.js";
+export { renderBlockKit, renderSlackMessage, buildFeedbackBlocks, FEEDBACK_ACTION_ID, } from "./render/block-kit.js";
+export { renderSlackModal } from "./render/modal.js";
+export { SLACK_LIMITS } from "./render/budget.js";
+export { NativeMessageStream } from "./native-stream.js";
+export { ChunkedMessageStream } from "./chunked-message-stream.js";
+export { MessageStream } from "./message-stream.js";
+export { markdownToMrkdwn } from "./markdown-to-mrkdwn.js";
+export { autoCloseOpenMarkdown } from "./auto-close-streaming.js";

package/dist/sanitizing-http-agent.d.ts

@@ -0,0 +1,28 @@
+import { HttpAgent } from "@ag-ui/client";
+import type { BaseEvent, RunAgentInput } from "@ag-ui/core";
+import type { Observable } from "rxjs";
+/**
+ * An `HttpAgent` that tolerates the AG-UI event streams real agents emit.
+ *
+ * `@ag-ui/client`'s stock transform re-validates every streamed event
+ * against a strict Zod schema. Some events that `@ag-ui/langgraph`
+ * legitimately emits fail it — notably a `TOOL_CALL_START` whose
+ * `parentMessageId` is `null` ("Expected string, received null") — and a
+ * single rejected event aborts the entire run. That breaks LangGraph
+ * interrupts / human-in-the-loop in Slack, where the tool call that
+ * triggers the interrupt carries exactly that shape.
+ *
+ * The bridge talks to a trusted runtime, so rather than re-validate its
+ * output we use the same SSE parse the stock path wraps
+ * (`parseSSEStream`) and coerce the known nullable-string fields. Note
+ * this deliberately drops the stock transform's *entire* strict Zod
+ * re-validation step (not just the offending field) — acceptable only
+ * because the runtime is trusted and `runHttpRequest` still throws on
+ * transport/HTTP errors. The first coercion logs a one-time breadcrumb so
+ * the workaround is visible in production. Revert to the stock transform
+ * (`transformHttpEventStream`) once upstream makes these fields nullable.
+ */
+export declare class SanitizingHttpAgent extends HttpAgent {
+    run(input: RunAgentInput): Observable<BaseEvent>;
+}
+//# sourceMappingURL=sanitizing-http-agent.d.ts.map

package/dist/sanitizing-http-agent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sanitizing-http-agent.d.ts","sourceRoot":"","sources":["../src/sanitizing-http-agent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAkC,MAAM,eAAe,CAAC;AAC1E,OAAO,KAAK,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAE5D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,MAAM,CAAC;AAEvC;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,qBAAa,mBAAoB,SAAQ,SAAS;IAChD,GAAG,CAAC,KAAK,EAAE,aAAa,GAAG,UAAU,CAAC,SAAS,CAAC;CAMjD"}