@copilotkit/channels-slack 0.1.0

package/dist/codec.js

@@ -0,0 +1,18 @@
+import { renderSlackMessage } from "./render/block-kit.js";
+import { normalizeSlackEvent } from "./ingress-normalize.js";
+/**
+ * Pure Slack codec — both directions, no Bolt and no Slack credentials. Shared
+ * by the local Slack adapter and (via the Connector Outbox / webhook ingress,
+ * OSS-362/363) the managed path, so platform semantics live in one place:
+ *
+ * - `renderEgress`: IR → Block Kit.
+ * - `normalizeIngress`: raw Slack payload (Events API envelope or slash-command
+ *   body) → platform-neutral ingress event. `normalizeIngress` is a Slack
+ *   extension on top of the generic egress-only {@link PlatformCodec}; the
+ *   caller applies its own policy/entitlement gating and builds the route.
+ */
+export const slackCodec = {
+    platform: "slack",
+    renderEgress: renderSlackMessage,
+    normalizeIngress: normalizeSlackEvent,
+};

package/dist/codec.test.d.ts

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

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

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

package/dist/codec.test.js

@@ -0,0 +1,19 @@
+import { describe, it, expect } from "vitest";
+import { slackCodec } from "./codec.js";
+describe("slackCodec", () => {
+    it("is the slack platform codec", () => {
+        expect(slackCodec.platform).toBe("slack");
+    });
+    it("renders IR to Slack Block Kit via the shared pure renderer", () => {
+        const ir = [
+            {
+                type: "section",
+                props: { children: [{ type: "text", props: { value: "hi" } }] },
+            },
+        ];
+        const out = slackCodec.renderEgress(ir);
+        expect(out.blocks).toEqual([
+            { type: "section", text: { type: "mrkdwn", text: "hi" } },
+        ]);
+    });
+});

package/dist/conversation-store.d.ts

@@ -0,0 +1,92 @@
+import type { HttpAgent } from "@ag-ui/client";
+import type { WebClient } from "@slack/web-api";
+import type { ConversationKey, ReplyTarget } from "./types.js";
+import { type FileDeliveryConfig } from "./download-files.js";
+/**
+ * One ongoing Slack conversation with the bot. Built fresh per turn from
+ * Slack's stored history — Slack itself is our durable storage, so the
+ * bridge keeps no separate state.
+ */
+export interface AgentSession {
+    threadId: string;
+    agent: HttpAgent;
+    replyTarget: ReplyTarget;
+}
+/**
+ * Backed entirely by Slack: every turn pulls the current thread (or DM)
+ * history via the Web API, translates it into the AG-UI message shape,
+ * and hands a fresh HttpAgent to the turn-runner. Bridge restarts are
+ * automatically robust because the bridge holds no state to lose.
+ *
+ * The only in-memory state is a participation cache — a `Set` of thread
+ * keys the bot has already replied to. It's a pure performance hint
+ * (avoids one Slack API call per thread-reply event in active
+ * conversations) and is rebuilt lazily after a restart by the same
+ * Slack lookup that already produces the answer.
+ */
+export declare class SlackConversationStore {
+    private readonly client;
+    private readonly botUserId;
+    /** Bot token used to download uploaded files from their `url_private`. */
+    private readonly botToken;
+    private readonly filesConfig;
+    /** Stable threadIds → conversation keys ("channelId::scope"). */
+    private readonly participated;
+    constructor(args: {
+        client: WebClient;
+        botUserId: string;
+        botToken: string;
+        files?: FileDeliveryConfig;
+    });
+    private keyOf;
+    /**
+     * A *fresh* AG-UI threadId per turn.
+     *
+     * We deliberately do NOT reuse a stable per-conversation threadId.
+     * Slack is our durable history (every turn is rebuilt from it via
+     * {@link fetchHistory}), so the LangGraph thread only needs to live for
+     * the duration of one turn. Reusing a stable threadId across turns lets
+     * the server-side thread accumulate the agent's *internal* messages
+     * (tool calls/results that never round-trip through Slack); on the next
+     * turn `@ag-ui/langgraph` regenerates state and the now-larger existing
+     * thread no longer matches the incoming history, surfacing as a
+     * "Message not found" failure. A unique thread per turn sidesteps that
+     * entirely. Restart-recovery for interrupts still works because the
+     * picker carries its turn's threadId in Slack message metadata (see
+     * `recoverFromStaleClick`).
+     */
+    private newThreadId;
+    /**
+     * Does the bot own this thread? "Ownership" means the bot has at least
+     * one prior reply in it (which is the natural definition since the bot
+     * only ever replies when @-mentioned or in a thread it already owns).
+     *
+     * Cached in-process; the first call after a restart is one Slack API
+     * round-trip, subsequent calls are O(1).
+     */
+    has(key: ConversationKey): Promise<boolean>;
+    /**
+     * Build a fresh AgentSession for this conversation by fetching its
+     * Slack history and translating it into the AG-UI message shape.
+     * `makeAgent` produces the HttpAgent; we set its `messages` to the
+     * translated history.
+     */
+    getOrCreate(key: ConversationKey, replyTarget: ReplyTarget, makeAgent: (threadId: string) => HttpAgent): Promise<AgentSession>;
+    /**
+     * No-op: the next call rebuilds from Slack, so there's nothing to
+     * persist. Kept on the API for symmetry with the previous interface
+     * (the turn-runner still calls it; we just do nothing).
+     */
+    save(_key: ConversationKey, _session: AgentSession): void;
+    /** Fetch Slack history for either a thread or a DM and translate. */
+    private fetchHistory;
+    /**
+     * Translate a chronological run of Slack messages to AG-UI messages,
+     * folding (a) our bot's chunked replies into a single assistant turn,
+     * (b) skipping our `:wrench:` / `:white_check_mark:` status messages
+     * and the `_thinking…_` placeholder, and (c) stripping `<@bot>`
+     * mention tokens from user text.
+     */
+    private translate;
+}
+//# sourceMappingURL=conversation-store.d.ts.map

package/dist/conversation-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conversation-store.d.ts","sourceRoot":"","sources":["../src/conversation-store.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC/C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAChD,OAAO,KAAK,EAAE,eAAe,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE/D,OAAO,EAGL,KAAK,kBAAkB,EAExB,MAAM,qBAAqB,CAAC;AAE7B;;;;GAIG;AACH,MAAM,WAAW,YAAY;IAC3B,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,SAAS,CAAC;IACjB,WAAW,EAAE,WAAW,CAAC;CAC1B;AAED;;;;;;;;;;;GAWG;AACH,qBAAa,sBAAsB;IACjC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAY;IACnC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,0EAA0E;IAC1E,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;IAClC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAqB;IACjD,iEAAiE;IACjE,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAqB;gBAEtC,IAAI,EAAE;QAChB,MAAM,EAAE,SAAS,CAAC;QAClB,SAAS,EAAE,MAAM,CAAC;QAClB,QAAQ,EAAE,MAAM,CAAC;QACjB,KAAK,CAAC,EAAE,kBAAkB,CAAC;KAC5B;IAOD,OAAO,CAAC,KAAK;IAIb;;;;;;;;;;;;;;;OAeG;IACH,OAAO,CAAC,WAAW;IAInB;;;;;;;OAOG;IACG,GAAG,CAAC,GAAG,EAAE,eAAe,GAAG,OAAO,CAAC,OAAO,CAAC;IAqBjD;;;;;OAKG;IACG,WAAW,CACf,GAAG,EAAE,eAAe,EACpB,WAAW,EAAE,WAAW,EACxB,SAAS,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,SAAS,GACzC,OAAO,CAAC,YAAY,CAAC;IAWxB;;;;OAIG;IACH,IAAI,CAAC,IAAI,EAAE,eAAe,EAAE,QAAQ,EAAE,YAAY,GAAG,IAAI;IAIzD,qEAAqE;YACvD,YAAY;IAsB1B;;;;;;OAMG;YACW,SAAS;CA4DxB"}

package/dist/conversation-store.js

@@ -0,0 +1,196 @@
+import { randomUUID } from "node:crypto";
+import { DM_SCOPE } from "./types.js";
+import { buildFileContentParts, } from "./download-files.js";
+/**
+ * Backed entirely by Slack: every turn pulls the current thread (or DM)
+ * history via the Web API, translates it into the AG-UI message shape,
+ * and hands a fresh HttpAgent to the turn-runner. Bridge restarts are
+ * automatically robust because the bridge holds no state to lose.
+ *
+ * The only in-memory state is a participation cache — a `Set` of thread
+ * keys the bot has already replied to. It's a pure performance hint
+ * (avoids one Slack API call per thread-reply event in active
+ * conversations) and is rebuilt lazily after a restart by the same
+ * Slack lookup that already produces the answer.
+ */
+export class SlackConversationStore {
+    client;
+    botUserId;
+    /** Bot token used to download uploaded files from their `url_private`. */
+    botToken;
+    filesConfig;
+    /** Stable threadIds → conversation keys ("channelId::scope"). */
+    participated = new Set();
+    constructor(args) {
+        this.client = args.client;
+        this.botUserId = args.botUserId;
+        this.botToken = args.botToken;
+        this.filesConfig = args.files ?? {};
+    }
+    keyOf(k) {
+        return `${k.channelId}::${k.scope}`;
+    }
+    /**
+     * A *fresh* AG-UI threadId per turn.
+     *
+     * We deliberately do NOT reuse a stable per-conversation threadId.
+     * Slack is our durable history (every turn is rebuilt from it via
+     * {@link fetchHistory}), so the LangGraph thread only needs to live for
+     * the duration of one turn. Reusing a stable threadId across turns lets
+     * the server-side thread accumulate the agent's *internal* messages
+     * (tool calls/results that never round-trip through Slack); on the next
+     * turn `@ag-ui/langgraph` regenerates state and the now-larger existing
+     * thread no longer matches the incoming history, surfacing as a
+     * "Message not found" failure. A unique thread per turn sidesteps that
+     * entirely. Restart-recovery for interrupts still works because the
+     * picker carries its turn's threadId in Slack message metadata (see
+     * `recoverFromStaleClick`).
+     */
+    newThreadId(k) {
+        return `slack-${k.channelId}-${k.scope}-${randomUUID()}`;
+    }
+    /**
+     * Does the bot own this thread? "Ownership" means the bot has at least
+     * one prior reply in it (which is the natural definition since the bot
+     * only ever replies when @-mentioned or in a thread it already owns).
+     *
+     * Cached in-process; the first call after a restart is one Slack API
+     * round-trip, subsequent calls are O(1).
+     */
+    async has(key) {
+        if (this.participated.has(this.keyOf(key)))
+            return true;
+        // DM "scope" is a sentinel — no Slack thread to query. We treat the
+        // listener-level DM gate as authoritative; DMs always go through.
+        if (key.scope === DM_SCOPE)
+            return false;
+        try {
+            const r = await this.client.conversations.replies({
+                channel: key.channelId,
+                ts: key.scope,
+                limit: 200,
+            });
+            const messages = (r.messages ?? []);
+            const owned = messages.some((m) => m.user === this.botUserId);
+            if (owned)
+                this.participated.add(this.keyOf(key));
+            return owned;
+        }
+        catch (err) {
+            console.warn("[store] has() lookup failed:", err);
+            return false;
+        }
+    }
+    /**
+     * Build a fresh AgentSession for this conversation by fetching its
+     * Slack history and translating it into the AG-UI message shape.
+     * `makeAgent` produces the HttpAgent; we set its `messages` to the
+     * translated history.
+     */
+    async getOrCreate(key, replyTarget, makeAgent) {
+        const threadId = this.newThreadId(key);
+        const agent = makeAgent(threadId);
+        const history = await this.fetchHistory(key);
+        agent.messages = history;
+        // Eagerly mark as ours so a follow-up arriving before the bot's first
+        // reply has settled into Slack still gets matched as "owned".
+        this.participated.add(this.keyOf(key));
+        return { threadId, agent, replyTarget };
+    }
+    /**
+     * No-op: the next call rebuilds from Slack, so there's nothing to
+     * persist. Kept on the API for symmetry with the previous interface
+     * (the turn-runner still calls it; we just do nothing).
+     */
+    save(_key, _session) {
+        /* intentionally empty */
+    }
+    /** Fetch Slack history for either a thread or a DM and translate. */
+    async fetchHistory(key) {
+        try {
+            if (key.scope === DM_SCOPE) {
+                const r = await this.client.conversations.history({
+                    channel: key.channelId,
+                    limit: 100,
+                });
+                const slackMsgs = (r.messages ?? []).reverse(); // oldest first
+                return this.translate(slackMsgs);
+            }
+            const r = await this.client.conversations.replies({
+                channel: key.channelId,
+                ts: key.scope,
+                limit: 200,
+            });
+            return this.translate((r.messages ?? []));
+        }
+        catch (err) {
+            console.warn("[store] fetchHistory failed:", err);
+            return [];
+        }
+    }
+    /**
+     * Translate a chronological run of Slack messages to AG-UI messages,
+     * folding (a) our bot's chunked replies into a single assistant turn,
+     * (b) skipping our `:wrench:` / `:white_check_mark:` status messages
+     * and the `_thinking…_` placeholder, and (c) stripping `<@bot>`
+     * mention tokens from user text.
+     */
+    async translate(messages) {
+        const MENTION_RE = /<@[UW][A-Z0-9]+>/g;
+        const isStatusOrPlaceholder = (text) => text.startsWith(":wrench:") ||
+            text.startsWith(":white_check_mark:") ||
+            text === "_thinking…_" ||
+            text === "_…(continued)_";
+        const out = [];
+        for (const m of messages) {
+            if (m.subtype && m.subtype !== "file_share")
+                continue;
+            // Bot's own messages: matched by user id, or by bot_id when the API
+            // omits `user` (legacy bot integrations). A user-token app message has
+            // BOTH user and bot_id — `!m.user` keeps those classified as user.
+            const isBot = m.user === this.botUserId || (!!m.bot_id && !m.user);
+            const hasFiles = !isBot && Array.isArray(m.files) && m.files.length > 0;
+            if (!m.text && !hasFiles)
+                continue;
+            if (isBot && isStatusOrPlaceholder(m.text ?? ""))
+                continue;
+            let text = m.text ?? "";
+            if (!isBot) {
+                text = text.replace(MENTION_RE, "").replace(/\s+/g, " ").trim();
+            }
+            const role = isBot ? "assistant" : "user";
+            // User message with uploaded files → multimodal content (the agent's
+            // model reads the images / decoded text). The bridge only delivers;
+            // the app decides what to do with the bytes.
+            if (hasFiles) {
+                const { parts, notes } = await buildFileContentParts(m.files, this.botToken, this.filesConfig);
+                const content = [];
+                if (text)
+                    content.push({ type: "text", text });
+                content.push(...parts);
+                if (notes.length > 0) {
+                    content.push({
+                        type: "text",
+                        text: `[attachment notes: ${notes.join("; ")}]`,
+                    });
+                }
+                if (content.length === 0)
+                    continue; // nothing usable
+                out.push({ id: m.ts ?? "", role, content });
+                continue;
+            }
+            if (!text)
+                continue;
+            // Fold consecutive same-role *string* messages — our chunked bot
+            // replies are one assistant turn, just rendered as N Slack messages.
+            const tail = out[out.length - 1];
+            if (tail && tail.role === role && typeof tail.content === "string") {
+                tail.content = `${tail.content}\n${text}`;
+            }
+            else {
+                out.push({ id: m.ts ?? "", role, content: text });
+            }
+        }
+        return out;
+    }
+}

package/dist/download-files.d.ts

@@ -0,0 +1,59 @@
+/** The subset of a Slack file object we use. */
+export interface SlackFileRef {
+    id?: string;
+    name?: string;
+    mimetype?: string;
+    filetype?: string;
+    url_private?: string;
+    size?: number;
+}
+/** A base64 data source, shared by every binary media part. */
+type MediaDataSource = {
+    type: "data";
+    value: string;
+    mimeType: string;
+};
+/**
+ * AG-UI multimodal content parts (shape the runtime's converter expects).
+ *
+ * Binary media (image/audio/video/document) is passed straight through as a
+ * data part; the agent's model decides what it can actually consume. Most
+ * models read images and PDFs; far fewer accept audio or video. The bridge
+ * stays transport-only and does not gate on model capability.
+ */
+export type AgentContentPart = {
+    type: "text";
+    text: string;
+} | {
+    type: "image";
+    source: MediaDataSource;
+} | {
+    type: "audio";
+    source: MediaDataSource;
+} | {
+    type: "video";
+    source: MediaDataSource;
+} | {
+    type: "document";
+    source: MediaDataSource;
+};
+/** Tunables for inbound file handling (all optional; sane defaults). */
+export interface FileDeliveryConfig {
+    /** Skip a single file larger than this many bytes. Default 8 MiB. */
+    maxBytesPerFile?: number;
+    /** Process at most this many files per message. Default 5. */
+    maxFiles?: number;
+    /** Truncate decoded text files to this many bytes. Default 200 KiB. */
+    maxTextBytes?: number;
+}
+/**
+ * Download a message's files and turn them into AG-UI content parts. Returns
+ * the parts plus human-readable `notes` for anything skipped (appended to the
+ * message as a text part by the caller).
+ */
+export declare function buildFileContentParts(files: SlackFileRef[], botToken: string, config?: FileDeliveryConfig): Promise<{
+    parts: AgentContentPart[];
+    notes: string[];
+}>;
+export {};
+//# sourceMappingURL=download-files.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"download-files.d.ts","sourceRoot":"","sources":["../src/download-files.ts"],"names":[],"mappings":"AAaA,gDAAgD;AAChD,MAAM,WAAW,YAAY;IAC3B,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,+DAA+D;AAC/D,KAAK,eAAe,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC;AAEzE;;;;;;;GAOG;AACH,MAAM,MAAM,gBAAgB,GACxB;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAC9B;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,eAAe,CAAA;CAAE,GAC1C;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,eAAe,CAAA;CAAE,GAC1C;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,eAAe,CAAA;CAAE,GAC1C;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,MAAM,EAAE,eAAe,CAAA;CAAE,CAAC;AAElD,wEAAwE;AACxE,MAAM,WAAW,kBAAkB;IACjC,qEAAqE;IACrE,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,8DAA8D;IAC9D,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,uEAAuE;IACvE,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAwCD;;;;GAIG;AACH,wBAAsB,qBAAqB,CACzC,KAAK,EAAE,YAAY,EAAE,EACrB,QAAQ,EAAE,MAAM,EAChB,MAAM,GAAE,kBAAuB,GAC9B,OAAO,CAAC;IAAE,KAAK,EAAE,gBAAgB,EAAE,CAAC;IAAC,KAAK,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC,CAwFzD"}

package/dist/download-files.js

@@ -0,0 +1,116 @@
+const DEFAULTS = {
+    maxBytesPerFile: 8 * 1024 * 1024,
+    maxFiles: 5,
+    maxTextBytes: 200 * 1024,
+};
+const TEXT_MIME_PREFIXES = ["text/"];
+const TEXT_MIME_EXACT = new Set([
+    "application/json",
+    "application/csv",
+    "application/xml",
+    "application/x-ndjson",
+    "application/yaml",
+]);
+function isText(mime) {
+    return (TEXT_MIME_PREFIXES.some((p) => mime.startsWith(p)) ||
+        TEXT_MIME_EXACT.has(mime));
+}
+/**
+ * The AG-UI media part type that carries this MIME, or null if it isn't a
+ * binary medium we pass through. Images/audio/video go by their top-level
+ * type; PDFs map to `document`. Everything else is left to the text path or
+ * skipped.
+ */
+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 a message's files and turn them into AG-UI content parts. Returns
+ * the parts plus human-readable `notes` for anything skipped (appended to the
+ * message as a text part by the caller).
+ */
+export async function buildFileContentParts(files, botToken, config = {}) {
+    const maxBytes = config.maxBytesPerFile ?? DEFAULTS.maxBytesPerFile;
+    const maxFiles = config.maxFiles ?? DEFAULTS.maxFiles;
+    const maxText = config.maxTextBytes ?? DEFAULTS.maxTextBytes;
+    const parts = [];
+    const notes = [];
+    const considered = files.slice(0, maxFiles);
+    if (files.length > maxFiles) {
+        notes.push(`(only the first ${maxFiles} of ${files.length} files processed)`);
+    }
+    for (const f of considered) {
+        const label = f.name ?? f.id ?? "file";
+        const mime = (f.mimetype ?? "").toLowerCase();
+        const media = mediaPartType(mime);
+        if (!f.url_private) {
+            notes.push(`skipped "${label}": no download URL`);
+            continue;
+        }
+        if (!media && !isText(mime)) {
+            notes.push(`skipped "${label}" (${mime || f.filetype || "unknown"}): unsupported type`);
+            continue;
+        }
+        if (typeof f.size === "number" && f.size > maxBytes) {
+            notes.push(`skipped "${label}": ${f.size} bytes exceeds the ${maxBytes}-byte cap`);
+            continue;
+        }
+        let bytes;
+        try {
+            const res = await fetch(f.url_private, {
+                headers: { Authorization: `Bearer ${botToken}` },
+            });
+            if (!res.ok) {
+                notes.push(`skipped "${label}": download failed (HTTP ${res.status})`);
+                continue;
+            }
+            bytes = Buffer.from(await res.arrayBuffer());
+        }
+        catch (err) {
+            notes.push(`skipped "${label}": ${err.message}`);
+            continue;
+        }
+        if (bytes.byteLength > maxBytes) {
+            notes.push(`skipped "${label}": ${bytes.byteLength} bytes exceeds the ${maxBytes}-byte cap`);
+            continue;
+        }
+        if (media) {
+            // Image/audio/video/PDF → a binary data part the model reads natively
+            // (subject to its modality support). The bridge just delivers it.
+            parts.push({
+                type: media,
+                source: {
+                    type: "data",
+                    value: bytes.toString("base64"),
+                    mimeType: mime,
+                },
+            });
+        }
+        else {
+            // Truncate the BYTES then decode — slicing the decoded string by
+            // character index would corrupt multi-byte UTF-8 (and not actually
+            // bound the byte length). toString drops any malformed trailing bytes.
+            let buf = bytes;
+            let truncated = false;
+            if (buf.byteLength > maxText) {
+                buf = buf.subarray(0, maxText);
+                truncated = true;
+            }
+            const text = buf.toString("utf8");
+            parts.push({
+                type: "text",
+                text: `Attached file "${label}" (${mime}${truncated ? ", truncated" : ""}):\n` +
+                    text,
+            });
+        }
+    }
+    return { parts, notes };
+}

package/dist/event-renderer.d.ts

@@ -0,0 +1,98 @@
+import type { KnownBlock } from "@slack/types";
+import type { RunRenderer } from "@copilotkit/channels";
+import type { NativeStreamTransport } from "./native-stream.js";
+import type { SlackRenderTransport } from "./render/transport.js";
+import type { SlackAssistantOptions } from "./types.js";
+/**
+ * Construct a {@link RunRenderer} for a single agent run in Slack.
+ *
+ * The `subscriber` is passed to `runAgent`. After the run resolves, the
+ * run-loop reads `getCapturedToolCalls()` (filtering by which tools are
+ * registered) and `getPendingInterrupt()`, then calls `finish()` once at
+ * turn end. `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.
+ *
+ * ## Native vs legacy text streaming
+ *
+ * When `nativeStreaming` is set, the run uses a SINGLE turn-scoped
+ * `chat.startStream` message for the whole turn: text from every AG-UI
+ * message accumulates into it (separated by blank lines), and tool calls
+ * surface as native `task_update` chunks INSIDE that message. The message is
+ * finalized once, at `finish()`, optionally carrying a feedback row. The
+ * legacy path keeps the prior behavior — one `chat.update` message per AG-UI
+ * text message, plus separate `:wrench:` tool-status rows.
+ */
+export declare function createRunRenderer(args: {
+    /**
+     * The credentialed Slack side-effects (setStatus / postMessage / update),
+     * injected so this renderer never imports `@slack/web-api`. The native
+     * adapter wraps a `WebClient`; the managed Connector Outbox wraps its own
+     * sender.
+     */
+    transport: SlackRenderTransport;
+    target: {
+        channel: string;
+        threadTs?: string;
+    };
+    /**
+     * 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>;
+    /**
+     * Master toggle for surfacing tool-call progress in the UI. Defaults to
+     * `true`. When `false`, NO tool progress is shown on any surface — native
+     * in-message `task_update` chunks, legacy `:wrench:` rows, and the pane's
+     * "is using `tool`…" composer status are all suppressed (tools still run;
+     * only the display is hidden). When `true`, the surface is chosen by target:
+     * native streaming → `task_update` chunks; legacy / native-degraded →
+     * `:wrench:`/`:white_check_mark:` rows; pane → composer status (further
+     * gated by the pane's own `toolStatus`).
+     *
+     * Status rows dedup by `toolCallId` so a tool that fires
+     * `TOOL_CALL_START` twice (e.g. on graph resume after an interrupt)
+     * can't post two rows for the same logical call.
+     */
+    showToolStatus?: boolean;
+    /**
+     * Present whenever the reply is anchored to a thread we can set native status
+     * on (pane, channel @-mention, channel thread, or a flat DM via its carried
+     * inbound ts). Drives Slack's native `assistant.threads.setStatus`
+     * ("is thinking…") instead of a placeholder message. `threadTs` is the thread
+     * the status attaches to; `isPane` selects how *tool* progress is surfaced
+     * (pane → composer "is using `tool`…"; non-pane → `task_update`/`:wrench:`).
+     */
+    status?: {
+        threadTs: string;
+        isPane: boolean;
+        config?: SlackAssistantOptions["status"];
+    };
+    /**
+     * When set, agent text replies stream via `chat.startStream` (native) using
+     * this transport instead of `chat.update`. Falls back to the legacy
+     * transport automatically if `startStream` fails. `onChunkFailure` flips the
+     * renderer to `:wrench:` tool-status rows if structured chunks are
+     * unsupported.
+     */
+    nativeStreaming?: {
+        transport: NativeStreamTransport;
+        onStartFailure?: (err: unknown) => void;
+        /**
+         * Whether structured `task_update` chunks are known to work on this
+         * workspace (adapter-persisted across turns). Defaults to `true`.
+         */
+        taskChunks?: boolean;
+        /** Called the first time a chunk append fails, so the adapter can persist the degradation. */
+        onChunkFailure?: () => void;
+    };
+    /**
+     * Native AI-feedback row (built by the adapter when `feedback` is
+     * configured) attached to the finalized streamed reply via `stopStream`.
+     * Native path only; omitted when absent or on legacy fallback.
+     */
+    feedbackBlocks?: KnownBlock[];
+}): 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":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE/C,OAAO,KAAK,EACV,WAAW,EAGZ,MAAM,sBAAsB,CAAC;AAK9B,OAAO,KAAK,EAAc,qBAAqB,EAAE,MAAM,oBAAoB,CAAC;AAC5E,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAC;AAClE,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAwBxD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE;IACtC;;;;;OAKG;IACH,SAAS,EAAE,oBAAoB,CAAC;IAChC,MAAM,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAC/C;;;;OAIG;IACH,mBAAmB,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IAC1C;;;;;;;;;;;;;OAaG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB;;;;;;;OAOG;IACH,MAAM,CAAC,EAAE;QACP,QAAQ,EAAE,MAAM,CAAC;QACjB,MAAM,EAAE,OAAO,CAAC;QAChB,MAAM,CAAC,EAAE,qBAAqB,CAAC,QAAQ,CAAC,CAAC;KAC1C,CAAC;IACF;;;;;;OAMG;IACH,eAAe,CAAC,EAAE;QAChB,SAAS,EAAE,qBAAqB,CAAC;QACjC,cAAc,CAAC,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,IAAI,CAAC;QACxC;;;WAGG;QACH,UAAU,CAAC,EAAE,OAAO,CAAC;QACrB,8FAA8F;QAC9F,cAAc,CAAC,EAAE,MAAM,IAAI,CAAC;KAC7B,CAAC;IACF;;;;OAIG;IACH,cAAc,CAAC,EAAE,UAAU,EAAE,CAAC;CAC/B,GAAG,WAAW,CAwcd"}