@copilotkit/channels-slack 0.1.0

package/dist/auto-close-streaming.js

@@ -0,0 +1,273 @@
+/**
+ * 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.
+ */
+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().reverse().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) {
+    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;
+        }
+    }
+    // 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 `**`.
+    while (stack.length > 0) {
+        const last = stack[stack.length - 1];
+        const lastIdx = text.lastIndexOf(last);
+        if (lastIdx < 0)
+            break;
+        const after = text.slice(lastIdx + last.length);
+        if (/^\s*$/.test(after)) {
+            stack.pop();
+        }
+        else {
+            break;
+        }
+    }
+    return stack;
+}
+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;
+}

package/dist/built-in-context.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Slack-platform-universal context entries — knowledge the LLM needs
+ * about Slack itself (tagging procedure, mrkdwn vs Markdown, thread
+ * model). Apps spread `defaultSlackContext` into the `context:` config
+ * they pass to `createBot`.
+ *
+ * Each entry is exported individually too so apps can cherry-pick.
+ */
+import type { ContextEntry } from "@copilotkit/channels";
+/** Slack context entry — alias of `@copilotkit/channels`'s {@link ContextEntry}. */
+export type SlackContextEntry = ContextEntry;
+export declare const slackTaggingContext: SlackContextEntry;
+export declare const slackFormattingContext: SlackContextEntry;
+export declare const slackConversationModelContext: SlackContextEntry;
+/**
+ * The default context entries the SDK ships. Spread into your
+ * `createBot({context: …})`:
+ *
+ *     context: [...defaultSlackContext, ...myAppContext],
+ */
+export declare const defaultSlackContext: ReadonlyArray<SlackContextEntry>;
+//# sourceMappingURL=built-in-context.d.ts.map

package/dist/built-in-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"built-in-context.d.ts","sourceRoot":"","sources":["../src/built-in-context.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAEzD,oFAAoF;AACpF,MAAM,MAAM,iBAAiB,GAAG,YAAY,CAAC;AAE7C,eAAO,MAAM,mBAAmB,EAAE,iBAqBjC,CAAC;AAEF,eAAO,MAAM,sBAAsB,EAAE,iBAiBpC,CAAC;AAEF,eAAO,MAAM,6BAA6B,EAAE,iBAa3C,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,EAAE,aAAa,CAAC,iBAAiB,CAIhE,CAAC"}

package/dist/built-in-context.js

@@ -0,0 +1,65 @@
+export const slackTaggingContext = {
+    description: "How to @-mention people on Slack — REQUIRED PROCEDURE",
+    value: [
+        "You are running on Slack. Whenever the user asks you to tag,",
+        "ping, @-mention, or otherwise notify a specific person by name,",
+        "handle, or email, you MUST follow this procedure BEFORE",
+        "composing your reply:",
+        "",
+        "  1. Call the `lookup_slack_user` tool with the person's name,",
+        "     handle, or email as the `query` argument.",
+        "  2. If the tool returns `found: true`, paste its `mention`",
+        "     field (e.g. `<@U05PN5700P9>`) verbatim wherever you would",
+        "     have written the person's name. This is the ONLY way Slack",
+        "     will actually ping them.",
+        "  3. If the tool returns `found: false`, write the person's",
+        "     plain name without an @ — never invent a `<@USERID>`.",
+        "",
+        'Plain text like "Atai" or "@atai" does NOT ping anyone — it',
+        "just renders as text. Skipping the tool when a tag was asked",
+        "for is a failure of the task.",
+    ].join("\n"),
+};
+export const slackFormattingContext = {
+    description: "Formatting Slack replies",
+    value: [
+        "Write standard Markdown — the bridge translates it to Slack's",
+        "mrkdwn for you before posting. Specifically:",
+        "",
+        "- **bold** and *italic* both work; the bridge converts.",
+        "- Use `inline code` and ```fenced code blocks``` normally.",
+        "- Markdown tables are auto-converted to column-aligned monospace",
+        "  blocks, which look much better than raw pipe tables on Slack.",
+        "- Bullet lists with `-` or `*` markers render correctly.",
+        "- Links: write `[text](https://url)` — they convert to <url|text>.",
+        "",
+        "Do NOT pre-emptively use Slack's mrkdwn syntax (single `*` for",
+        "bold, single `_` for italic, etc.) — that breaks the translator",
+        "and looks wrong. Just write standard Markdown.",
+    ].join("\n"),
+};
+export const slackConversationModelContext = {
+    description: "Slack conversation model",
+    value: [
+        "Each conversation is either a thread (the bot was @-mentioned in",
+        "a channel and reply lives in the thread it created) or a DM. Your",
+        "replies show up in the same surface — you don't need to handle",
+        "routing yourself.",
+        "",
+        "When a user replies in a thread you previously answered in, they",
+        "don't need to re-@-mention the bot — just continue the thread",
+        "naturally. If they send a fresh top-level message in a channel,",
+        "they MUST @-mention the bot for it to see them.",
+    ].join("\n"),
+};
+/**
+ * The default context entries the SDK ships. Spread into your
+ * `createBot({context: …})`:
+ *
+ *     context: [...defaultSlackContext, ...myAppContext],
+ */
+export const defaultSlackContext = [
+    slackTaggingContext,
+    slackFormattingContext,
+    slackConversationModelContext,
+];

package/dist/built-in-tools.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Slack-platform-universal frontend tools — tools every Slack bot
+ * benefits from, regardless of what the bot does. Apps spread
+ * `defaultSlackTools` into the `tools:` config they pass to
+ * `createBot`.
+ */
+import { z } from "zod";
+import { type BotTool } from "@copilotkit/channels";
+export declare const lookupSlackUserTool: BotTool<z.ZodObject<{
+    query: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    query: string;
+}, {
+    query: string;
+}>>;
+/**
+ * The flat list of tools the SDK ships. Spread into your
+ * `createBot({tools: …})`:
+ *
+ *     tools: [...defaultSlackTools, ...myAppTools],
+ */
+export declare const defaultSlackTools: ReadonlyArray<BotTool>;
+//# sourceMappingURL=built-in-tools.d.ts.map

package/dist/built-in-tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"built-in-tools.d.ts","sourceRoot":"","sources":["../src/built-in-tools.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAiB,KAAK,OAAO,EAAE,MAAM,sBAAsB,CAAC;AAWnE,eAAO,MAAM,mBAAmB;;;;;;GAwB9B,CAAC;AAEH;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB,EAAE,aAAa,CAAC,OAAO,CAAyB,CAAC"}

package/dist/built-in-tools.js

@@ -0,0 +1,45 @@
+/**
+ * Slack-platform-universal frontend tools — tools every Slack bot
+ * benefits from, regardless of what the bot does. Apps spread
+ * `defaultSlackTools` into the `tools:` config they pass to
+ * `createBot`.
+ */
+import { z } from "zod";
+import { defineBotTool } from "@copilotkit/channels";
+const lookupSchema = z.object({
+    query: z
+        .string()
+        .min(1)
+        .describe("Handle, display name, first name, or email of the person to look up."),
+});
+export const lookupSlackUserTool = defineBotTool({
+    name: "lookup_slack_user",
+    description: "Resolve a person to a Slack user ID so you can @-mention them. " +
+        "Accepts a handle (`atai`), display name (`Atai Barkai`), first name, " +
+        "or email. Returns an object with `found`, and on success a " +
+        "`mention` string (e.g. `<@U0B45V75NNR>`) — put that string verbatim " +
+        "in your reply to ping them. If `found` is false, write the plain " +
+        "name instead.",
+    parameters: lookupSchema,
+    async handler({ query }, { thread }) {
+        const u = await thread.lookupUser(query);
+        return u
+            ? {
+                found: true,
+                query,
+                userId: u.id,
+                name: u.name,
+                handle: u.handle,
+                email: u.email,
+                mention: `<@${u.id}>`,
+            }
+            : { found: false, query };
+    },
+});
+/**
+ * The flat list of tools the SDK ships. Spread into your
+ * `createBot({tools: …})`:
+ *
+ *     tools: [...defaultSlackTools, ...myAppTools],
+ */
+export const defaultSlackTools = [lookupSlackUserTool];

package/dist/chunked-message-stream.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Slack caps `chat.update` text at ~4000 chars. For longer agent responses we
+ * spread the text over several Slack messages — but the *chunk boundaries*
+ * must be stable once committed (we can't reflow a sentence into a previous
+ * chunk after that chunk has already been posted to Slack).
+ *
+ * ChunkedMessageStream owns N underlying `MessageStream`s (one per Slack
+ * message). It accepts the full accumulated text on `append()`, decides
+ * where the chunk boundaries are, mints new Slack messages as needed,
+ * and dispatches the right slice to each chunk's stream.
+ *
+ * Boundaries are chosen greedily: once an active chunk exceeds the soft
+ * limit, freeze the boundary at the last newline (or last space) within
+ * the limit; remaining text becomes the next chunk. Boundaries don't
+ * move once frozen, so an already-posted chunk's text never shrinks.
+ */
+export interface ChunkedMessageStreamConfig {
+    /** Soft per-message char limit. Defaults to 3500 (under Slack's ~4000). */
+    limit?: number;
+    /** Throttle floor for each underlying stream's chat.update. */
+    minIntervalMs?: number;
+    /** Posts a new Slack message with placeholder text; resolves with its `ts`. */
+    postPlaceholder: (text: string) => Promise<string>;
+    /** Updates the Slack message at `ts` with `text`. */
+    updateAt: (ts: string, text: string) => Promise<void>;
+    /**
+     * Optional transformer for the text *just before* it hits chat.update —
+     * e.g. markdown→mrkdwn translation. Applied per-chunk.
+     */
+    transform?: (text: string) => string;
+}
+export declare class ChunkedMessageStream {
+    private buffer;
+    /** Sorted positions where a chunk ends (= where the next chunk begins). */
+    private boundaries;
+    private streams;
+    /** Serialises new-chunk creation so async postPlaceholder calls don't race. */
+    private setupPromise;
+    private finished;
+    private readonly limit;
+    private readonly minIntervalMs;
+    private readonly postPlaceholder;
+    private readonly updateAt;
+    private readonly transform;
+    constructor(config: ChunkedMessageStreamConfig);
+    append(fullText: string): void;
+    finish(): Promise<void>;
+    /** Returns the number of Slack messages this stream has posted so far. */
+    get chunkCount(): number;
+    /**
+     * Walk forward from the last frozen boundary, freezing new ones whenever
+     * the active chunk's length exceeds the soft limit. Once frozen, a
+     * boundary doesn't move.
+     *
+     * Special case (block-keeps-whole): if the chosen boundary lands INSIDE
+     * an open fenced code block, we try to move the boundary BACK to the
+     * position right before the fence opener, so the *whole* block lives in
+     * the next Slack message rather than being split. The previous chunk
+     * gets shortened (chat.update will edit it down). Fallback when the
+     * block is too large to fit in one chunk: keep the inside-fence
+     * boundary; the dispatcher will prepend the fence opener to the next
+     * chunk (re-opener path).
+     */
+    private refreezeBoundaries;
+    private ensureStreamsAndDispatch;
+}
+//# sourceMappingURL=chunked-message-stream.d.ts.map

package/dist/chunked-message-stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunked-message-stream.d.ts","sourceRoot":"","sources":["../src/chunked-message-stream.ts"],"names":[],"mappings":"AAkBA;;;;;;;;;;;;;;;GAeG;AACH,MAAM,WAAW,0BAA0B;IACzC,2EAA2E;IAC3E,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,+DAA+D;IAC/D,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,+EAA+E;IAC/E,eAAe,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;IACnD,qDAAqD;IACrD,QAAQ,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACtD;;;OAGG;IACH,SAAS,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC;CACtC;AAID,qBAAa,oBAAoB;IAC/B,OAAO,CAAC,MAAM,CAAM;IACpB,2EAA2E;IAC3E,OAAO,CAAC,UAAU,CAAgB;IAClC,OAAO,CAAC,OAAO,CAAuB;IACtC,+EAA+E;IAC/E,OAAO,CAAC,YAAY,CAAoC;IACxD,OAAO,CAAC,QAAQ,CAAS;IAEzB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAS;IAC/B,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAqB;IACnD,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAoC;IACpE,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA8C;IACvE,OAAO,CAAC,QAAQ,CAAC,SAAS,CAA2B;gBAEzC,MAAM,EAAE,0BAA0B;IAQ9C,MAAM,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;IAWxB,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC;IAU7B,0EAA0E;IAC1E,IAAI,UAAU,IAAI,MAAM,CAEvB;IAED;;;;;;;;;;;;;OAaG;IACH,OAAO,CAAC,kBAAkB;YA0BZ,wBAAwB;CAsCvC"}

package/dist/chunked-message-stream.js

@@ -0,0 +1,134 @@
+import { MessageStream } from "./message-stream.js";
+import { detectOpenContext, renderContextOpener, } from "./auto-close-streaming.js";
+/**
+ * Position (0-based) of the unpaired opening ``` in `buffer.slice(0, end)`,
+ * or null if all triple-backticks before `end` are paired.
+ */
+function findUnpairedFenceStart(buffer, end) {
+    const before = buffer.slice(0, end);
+    const parts = before.split("```");
+    // length is odd → balanced; even → one unpaired opener exists
+    if (parts.length % 2 !== 0)
+        return null;
+    return before.lastIndexOf("```");
+}
+const DEFAULT_LIMIT = 3500;
+export class ChunkedMessageStream {
+    buffer = "";
+    /** Sorted positions where a chunk ends (= where the next chunk begins). */
+    boundaries = [];
+    streams = [];
+    /** Serialises new-chunk creation so async postPlaceholder calls don't race. */
+    setupPromise = Promise.resolve();
+    finished = false;
+    limit;
+    minIntervalMs;
+    postPlaceholder;
+    updateAt;
+    transform;
+    constructor(config) {
+        this.limit = config.limit ?? DEFAULT_LIMIT;
+        this.minIntervalMs = config.minIntervalMs;
+        this.postPlaceholder = config.postPlaceholder;
+        this.updateAt = config.updateAt;
+        this.transform = config.transform ?? ((t) => t);
+    }
+    append(fullText) {
+        if (this.finished)
+            return;
+        if (fullText === this.buffer)
+            return;
+        this.buffer = fullText;
+        this.refreezeBoundaries();
+        // Make sure we have one Slack message per chunk, then dispatch.
+        this.setupPromise = this.setupPromise.then(() => this.ensureStreamsAndDispatch());
+    }
+    async finish() {
+        this.finished = true;
+        // Drain any pending setup, then a final dispatch, then finish each stream.
+        this.setupPromise = this.setupPromise.then(() => this.ensureStreamsAndDispatch());
+        await this.setupPromise;
+        for (const s of this.streams)
+            await s.finish();
+    }
+    /** Returns the number of Slack messages this stream has posted so far. */
+    get chunkCount() {
+        return this.streams.length;
+    }
+    /**
+     * Walk forward from the last frozen boundary, freezing new ones whenever
+     * the active chunk's length exceeds the soft limit. Once frozen, a
+     * boundary doesn't move.
+     *
+     * Special case (block-keeps-whole): if the chosen boundary lands INSIDE
+     * an open fenced code block, we try to move the boundary BACK to the
+     * position right before the fence opener, so the *whole* block lives in
+     * the next Slack message rather than being split. The previous chunk
+     * gets shortened (chat.update will edit it down). Fallback when the
+     * block is too large to fit in one chunk: keep the inside-fence
+     * boundary; the dispatcher will prepend the fence opener to the next
+     * chunk (re-opener path).
+     */
+    refreezeBoundaries() {
+        let lastFrozen = this.boundaries.at(-1) ?? 0;
+        while (this.buffer.length - lastFrozen > this.limit) {
+            const window = this.buffer.slice(lastFrozen, lastFrozen + this.limit);
+            let breakAt = window.lastIndexOf("\n");
+            if (breakAt < this.limit / 4)
+                breakAt = window.lastIndexOf(" ");
+            if (breakAt < 0)
+                breakAt = this.limit - 1;
+            let candidate = lastFrozen + breakAt + 1;
+            // Block-keeps-whole: move boundary back if it lands inside an open
+            // fence. Only adjust if the fence opener is in the latter ~70% of
+            // the active chunk — otherwise shrinking would lose too much
+            // content (chunk N would be tiny) and the re-opener path is better.
+            const fenceStart = findUnpairedFenceStart(this.buffer, candidate);
+            if (fenceStart !== null) {
+                const minAcceptable = lastFrozen + Math.floor(this.limit * 0.3);
+                if (fenceStart > minAcceptable) {
+                    candidate = fenceStart;
+                }
+            }
+            this.boundaries.push(candidate);
+            lastFrozen = candidate;
+        }
+    }
+    async ensureStreamsAndDispatch() {
+        // If we've never received any content, don't post a placeholder. This
+        // matters for the empty-response case (D20): a TEXT_MESSAGE_START + END
+        // pair with no content events should produce no Slack message.
+        if (this.buffer.length === 0)
+            return;
+        const chunkCount = this.boundaries.length + 1;
+        while (this.streams.length < chunkCount) {
+            const i = this.streams.length;
+            const placeholder = i === 0 ? "_thinking…_" : "_…(continued)_";
+            const ts = await this.postPlaceholder(placeholder);
+            this.streams.push(new MessageStream({
+                update: (text) => this.updateAt(ts, this.transform(text) || " "),
+                minIntervalMs: this.minIntervalMs,
+            }));
+        }
+        // Dispatch slices.
+        //
+        // For continuation chunks (i > 0), if the boundary fell inside an open
+        // markdown construct (e.g. inside a ```python block), prepend the
+        // opener for that construct to the slice. Otherwise the second Slack
+        // message would begin with raw code that Slack renders as plain text.
+        // The closer at the end of the chunk is added by `transform`
+        // (autoCloseOpenMarkdown), which runs per chunk.
+        for (let i = 0; i < chunkCount; i++) {
+            const start = i === 0 ? 0 : this.boundaries[i - 1];
+            const end = i < this.boundaries.length ? this.boundaries[i] : this.buffer.length;
+            let slice = this.buffer.slice(start, end);
+            if (i > 0) {
+                const ctx = detectOpenContext(this.buffer.slice(0, start));
+                const opener = renderContextOpener(ctx);
+                if (opener)
+                    slice = opener + slice;
+            }
+            this.streams[i].append(slice);
+        }
+    }
+}

package/dist/codec.d.ts

@@ -0,0 +1,18 @@
+import type { PlatformCodec } from "@copilotkit/channels";
+import { normalizeSlackEvent } from "./ingress-normalize.js";
+import type { SlackNeutralEvent } 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 declare const slackCodec: PlatformCodec & {
+    normalizeIngress: (body: Parameters<typeof normalizeSlackEvent>[0], botUserId?: string) => SlackNeutralEvent | undefined;
+};
+//# sourceMappingURL=codec.d.ts.map

package/dist/codec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codec.d.ts","sourceRoot":"","sources":["../src/codec.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAE1D,OAAO,EAAE,mBAAmB,EAAE,MAAM,wBAAwB,CAAC;AAC7D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAEhE;;;;;;;;;;GAUG;AACH,eAAO,MAAM,UAAU,EAAE,aAAa,GAAG;IACvC,gBAAgB,EAAE,CAChB,IAAI,EAAE,UAAU,CAAC,OAAO,mBAAmB,CAAC,CAAC,CAAC,CAAC,EAC/C,SAAS,CAAC,EAAE,MAAM,KACf,iBAAiB,GAAG,SAAS,CAAC;CAKpC,CAAC"}