@copilotkit/channels-slack 0.1.0

package/dist/sanitizing-http-agent.js

@@ -0,0 +1,51 @@
+import { HttpAgent, parseSSEStream, runHttpRequest } from "@ag-ui/client";
+import { map } 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 class SanitizingHttpAgent extends HttpAgent {
+    run(input) {
+        return parseSSEStream(runHttpRequest(() => this.fetch(this.url, this.requestInit(input))), this.debugLogger).pipe(map((event) => coerceNullStrings(event)));
+    }
+}
+/** One-time breadcrumb so the workaround's use is visible in production. */
+let coercionWarned = false;
+/**
+ * Coerce known nullable-string event fields to `""`. Targeted on purpose:
+ * we only touch fields where a `null` is known to come through from
+ * `@ag-ui/langgraph` and would otherwise trip a downstream string check.
+ */
+function coerceNullStrings(event) {
+    if (!event || typeof event !== "object")
+        return event;
+    const e = event;
+    if (e["parentMessageId"] === null) {
+        e["parentMessageId"] = "";
+        if (!coercionWarned) {
+            coercionWarned = true;
+            console.warn('[SanitizingHttpAgent] coerced a null `parentMessageId` to "" and ' +
+                "bypassed @ag-ui/client strict event re-validation for this stream " +
+                "(known @ag-ui/langgraph quirk). Remove this agent once upstream " +
+                "makes the field nullable.");
+        }
+    }
+    return e;
+}

package/dist/slack-listener.d.ts

@@ -0,0 +1,73 @@
+import type { App } from "@slack/bolt";
+import type { WebClient } from "@slack/web-api";
+import type { SlackConversationStore } from "./conversation-store.js";
+import type { IncomingTurn, ResolvedSlackRespondToOptions } from "./types.js";
+/**
+ * Handler the listener calls when a Slack event maps to a usable turn.
+ * The listener doesn't know what happens next — it just hands off.
+ */
+export type TurnHandler = (turn: IncomingTurn, client: WebClient) => Promise<void> | void;
+/** A normalized slash-command invocation the listener hands off. */
+export interface SlackCommand {
+    /** Command name as Slack sent it, including the leading slash (e.g. "/triage"). */
+    command: string;
+    /** The argument string after the command. */
+    text: string;
+    conversation: {
+        channelId: string;
+        scope: string;
+    };
+    replyTarget: {
+        channel: string;
+    };
+    senderUserId?: string;
+    /** Opaque platform trigger for opening a modal (Slack `trigger_id`). */
+    triggerId?: string;
+    /**
+     * Stable per-invocation id for inbound idempotency. Slash commands carry no
+     * Events API `event_id`, so this is derived from
+     * `${command}:${user_id}:${trigger_id}` — the closest stable-per-click value
+     * Slack provides.
+     */
+    eventId?: string;
+}
+export type CommandHandler = (command: SlackCommand, client: WebClient) => Promise<void> | void;
+export interface ListenerConfig {
+    app: App;
+    /** Conversation store — used to check whether a thread-reply is "ours". */
+    store: SlackConversationStore;
+    /** Bot user id, used to filter out our own messages (loop guard). */
+    botUserId: string | undefined;
+    /** Resolved response-routing policy for Slack ingress. */
+    respondTo?: ResolvedSlackRespondToOptions;
+    /** Where each accepted turn is dispatched. */
+    onTurn: TurnHandler;
+    /** Where each slash command is dispatched. */
+    onCommand: CommandHandler;
+    /**
+     * True if `(channel, threadTs)` is an assistant-pane thread (owned by the
+     * Assistant middleware). When provided, threaded `message.im` events for
+     * those threads are skipped here so each pane message becomes exactly one
+     * turn. Absent (or returning false) → messages flow as shipped.
+     */
+    isAssistantThread?: (channel: string, threadTs: string) => boolean;
+}
+/**
+ * Attach Slack event handlers to a Bolt app. After this returns, the listener
+ * is the sole writer of IncomingTurn events — anything downstream sees a
+ * stream of cleanly-normalised turns regardless of which Slack event fired.
+ *
+ * Triggers:
+ *   1. @mention in a channel/thread → start or continue a conversation.
+ *   2. DM to the bot                → reply flat in the DM.
+ *   3. Plain reply in a tracked thread when explicitly configured.
+ *
+ * Filters out:
+ *   - `subtype` events (edits, joins, channel_renames, …)
+ *   - bot messages (any `bot_id`, including our own posts)
+ *   - top-level channel chatter we weren't @-mentioned in
+ *   - the `message.channels` event that arrives alongside every `app_mention`
+ *     (we recognise it by the presence of `<@botUserId>` in the text)
+ */
+export declare function attachSlackListener(config: ListenerConfig): void;
+//# sourceMappingURL=slack-listener.d.ts.map

package/dist/slack-listener.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slack-listener.d.ts","sourceRoot":"","sources":["../src/slack-listener.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,aAAa,CAAC;AACvC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAChD,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,yBAAyB,CAAC;AACtE,OAAO,KAAK,EAAE,YAAY,EAAE,6BAA6B,EAAE,MAAM,YAAY,CAAC;AAQ9E;;;GAGG;AACH,MAAM,MAAM,WAAW,GAAG,CACxB,IAAI,EAAE,YAAY,EAClB,MAAM,EAAE,SAAS,KACd,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;AAE1B,oEAAoE;AACpE,MAAM,WAAW,YAAY;IAC3B,mFAAmF;IACnF,OAAO,EAAE,MAAM,CAAC;IAChB,6CAA6C;IAC7C,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,EAAE;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IACnD,WAAW,EAAE;QAAE,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;IACjC,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,wEAAwE;IACxE,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;;;OAKG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,MAAM,cAAc,GAAG,CAC3B,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,SAAS,KACd,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;AAE1B,MAAM,WAAW,cAAc;IAC7B,GAAG,EAAE,GAAG,CAAC;IACT,2EAA2E;IAC3E,KAAK,EAAE,sBAAsB,CAAC;IAC9B,qEAAqE;IACrE,SAAS,EAAE,MAAM,GAAG,SAAS,CAAC;IAC9B,0DAA0D;IAC1D,SAAS,CAAC,EAAE,6BAA6B,CAAC;IAC1C,8CAA8C;IAC9C,MAAM,EAAE,WAAW,CAAC;IACpB,8CAA8C;IAC9C,SAAS,EAAE,cAAc,CAAC;IAC1B;;;;;OAKG;IACH,iBAAiB,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC;CACpE;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,cAAc,GAAG,IAAI,CAsIhE"}

package/dist/slack-listener.js

@@ -0,0 +1,126 @@
+import { DEFAULT_SLACK_RESPOND_TO_OPTIONS, DM_SCOPE } from "./types.js";
+import { stripMentions, deriveEventId, isPlainUserMessage, } from "./ingress-normalize.js";
+/**
+ * Attach Slack event handlers to a Bolt app. After this returns, the listener
+ * is the sole writer of IncomingTurn events — anything downstream sees a
+ * stream of cleanly-normalised turns regardless of which Slack event fired.
+ *
+ * Triggers:
+ *   1. @mention in a channel/thread → start or continue a conversation.
+ *   2. DM to the bot                → reply flat in the DM.
+ *   3. Plain reply in a tracked thread when explicitly configured.
+ *
+ * Filters out:
+ *   - `subtype` events (edits, joins, channel_renames, …)
+ *   - bot messages (any `bot_id`, including our own posts)
+ *   - top-level channel chatter we weren't @-mentioned in
+ *   - the `message.channels` event that arrives alongside every `app_mention`
+ *     (we recognise it by the presence of `<@botUserId>` in the text)
+ */
+export function attachSlackListener(config) {
+    const { app, store, onTurn, onCommand } = config;
+    const respondTo = config.respondTo ?? DEFAULT_SLACK_RESPOND_TO_OPTIONS;
+    // ── Slash commands ──────────────────────────────────────────────────
+    // Forward EVERY registered slash command to the engine, which routes it
+    // to the matching `bot.onCommand` handler (and ignores unregistered ones).
+    // We ack immediately (Slack's 3s deadline) and hand off; the handler does
+    // the slow work. Slack only delivers commands declared in the app config,
+    // so the `/.*/ ` matcher just catches whatever Slack sends.
+    // The command's args aren't posted to the channel, so we synthesise a
+    // stable per-(user) scope, letting a user re-run a command and continue
+    // the same conversation.
+    app.command(/.*/, async ({ command, ack, client }) => {
+        await ack();
+        await onCommand({
+            command: command.command,
+            text: (command.text ?? "").trim(),
+            conversation: {
+                channelId: command.channel_id,
+                scope: `slash::${command.user_id}`,
+            },
+            replyTarget: { channel: command.channel_id },
+            senderUserId: command.user_id,
+            triggerId: command.trigger_id,
+            // Slash commands carry no Events API event_id; trigger_id is the most
+            // stable per-invocation value Slack provides.
+            eventId: command.trigger_id
+                ? `${command.command}:${command.user_id}:${command.trigger_id}`
+                : undefined,
+        }, client);
+    });
+    app.event("app_mention", async ({ event, body, client }) => {
+        if (respondTo.appMentions === false)
+            return;
+        const threadTs = event.thread_ts ?? event.ts;
+        const userText = stripMentions(event.text ?? "");
+        const hasFiles = Array.isArray(event.files) &&
+            event.files.length > 0;
+        // Fire on a mention with an attachment even if the only text is the
+        // mention itself (e.g. "@bot" + a CSV). The store reads the file.
+        if (!userText && !hasFiles)
+            return;
+        await onTurn({
+            conversation: { channelId: event.channel, scope: threadTs },
+            replyTarget: respondTo.appMentions.reply === "thread"
+                ? { channel: event.channel, threadTs }
+                : { channel: event.channel },
+            userText,
+            senderUserId: event.user,
+            eventId: deriveEventId(body, event, event.channel),
+        }, client);
+    });
+    app.message(async ({ message, body, client }) => {
+        if (!isPlainUserMessage(message, config.botUserId))
+            return;
+        const text = (message.text ?? "").trim();
+        const hasFiles = Array.isArray(message.files) && message.files.length > 0;
+        // A bare file upload has empty text but is still a real turn.
+        if (!text && !hasFiles)
+            return;
+        const isDM = message.channel_type === "im";
+        // Pane messages are threaded DMs owned by the Assistant middleware — skip
+        // them here so each pane message becomes EXACTLY ONE turn. Gated per-THREAD
+        // (assistant threads tracked at runtime), never per-config: ordinary
+        // threaded DMs in apps without the Agents toggle keep flowing.
+        if (isDM &&
+            message.thread_ts &&
+            config.isAssistantThread?.(message.channel, message.thread_ts))
+            return;
+        if (!respondTo.directMessages)
+            return;
+        if (isDM) {
+            await onTurn({
+                conversation: { channelId: message.channel, scope: DM_SCOPE },
+                // Flat DM reply (no threadTs); carry the inbound ts so the renderer
+                // can anchor the native "is thinking…" status to a thread.
+                replyTarget: { channel: message.channel, statusTs: message.ts },
+                userText: text,
+                senderUserId: message.user,
+                eventId: deriveEventId(body, message, message.channel),
+            }, client);
+            return;
+        }
+        if (!message.thread_ts)
+            return; // top-level channel chatter — ignore
+        // app_mention runs separately for these; skip the duplicate.
+        if (config.botUserId && text.includes(`<@${config.botUserId}>`))
+            return;
+        if (respondTo.threadReplies === "mentionsOnly")
+            return;
+        // Only continue threads we already own. `has` consults Slack itself,
+        // so a restarted bridge naturally recognises threads it replied to
+        // before the restart.
+        if (!(await store.has({
+            channelId: message.channel,
+            scope: message.thread_ts,
+        })))
+            return;
+        await onTurn({
+            conversation: { channelId: message.channel, scope: message.thread_ts },
+            replyTarget: { channel: message.channel, threadTs: message.thread_ts },
+            userText: stripMentions(text),
+            senderUserId: message.user,
+            eventId: deriveEventId(body, message, message.channel),
+        }, client);
+    });
+}

package/dist/slack-listener.test.d.ts

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

package/dist/slack-listener.test.d.ts.map

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

package/dist/slack-listener.test.js

@@ -0,0 +1,115 @@
+import { describe, it, expect, vi } from "vitest";
+import { attachSlackListener } from "./slack-listener.js";
+/**
+ * Capture the Bolt handlers `attachSlackListener` registers, without a real
+ * App. Each `app.command/event/message` records its handler so a test can
+ * invoke it with a representative Slack payload and assert on the emitted
+ * ingress object.
+ */
+function captureListener(opts) {
+    let commandHandler;
+    let mentionHandler;
+    let messageHandler;
+    const app = {
+        command: vi.fn((_m, h) => {
+            commandHandler = h;
+        }),
+        event: vi.fn((_name, h) => {
+            mentionHandler = h;
+        }),
+        message: vi.fn((h) => {
+            messageHandler = h;
+        }),
+    };
+    const store = {
+        has: vi.fn(async () => opts?.storeHas ?? true),
+    };
+    const turns = [];
+    const commands = [];
+    attachSlackListener({
+        app,
+        store,
+        botUserId: "UBOT",
+        onTurn: (turn) => {
+            turns.push(turn);
+        },
+        onCommand: (cmd) => {
+            commands.push(cmd);
+        },
+    });
+    return {
+        turns,
+        commands,
+        command: (args) => commandHandler(args),
+        mention: (args) => mentionHandler(args),
+        message: (args) => messageHandler(args),
+    };
+}
+const client = {};
+describe("attachSlackListener eventId (inbound dedup)", () => {
+    it("derives a turn eventId from the Events API envelope event_id for an app_mention", async () => {
+        const l = captureListener();
+        await l.mention({
+            event: {
+                channel: "C1",
+                user: "U1",
+                text: "<@UBOT> hi",
+                ts: "100.0",
+                client_msg_id: "cmid-1",
+            },
+            body: { event_id: "Ev123ABC" },
+            client,
+        });
+        expect(l.turns).toHaveLength(1);
+        // event_id wins over client_msg_id / ts.
+        expect(l.turns[0].eventId).toBe("Ev123ABC");
+    });
+    it("falls back to client_msg_id then ${channel}:${ts} when no envelope event_id", async () => {
+        const l = captureListener();
+        // DM message with client_msg_id but no envelope event_id.
+        await l.message({
+            message: {
+                channel: "D9",
+                channel_type: "im",
+                user: "U1",
+                text: "hello",
+                ts: "200.1",
+                client_msg_id: "cmid-2",
+            },
+            body: {},
+            client,
+        });
+        expect(l.turns).toHaveLength(1);
+        expect(l.turns[0].eventId).toBe("cmid-2");
+        // Without client_msg_id, falls back to channel:ts.
+        const l2 = captureListener();
+        await l2.message({
+            message: {
+                channel: "D9",
+                channel_type: "im",
+                user: "U1",
+                text: "hello",
+                ts: "200.2",
+            },
+            body: {},
+            client,
+        });
+        expect(l2.turns[0].eventId).toBe("D9:200.2");
+    });
+    it("derives a stable command eventId from command:user:trigger_id", async () => {
+        const l = captureListener();
+        await l.command({
+            command: {
+                command: "/triage",
+                text: "now",
+                channel_id: "C1",
+                user_id: "U1",
+                trigger_id: "trig-9",
+            },
+            ack: vi.fn(async () => { }),
+            client,
+        });
+        expect(l.commands).toHaveLength(1);
+        expect(l.commands[0].eventId).toBe("/triage:U1:trig-9");
+    });
+});

package/dist/types.d.ts

@@ -0,0 +1,153 @@
+import type { PlatformUser } from "@copilotkit/channels";
+/**
+ * Where to post a reply in Slack. Used by the renderer; constructed by the
+ * listener once per turn.
+ */
+export interface ReplyTarget {
+    channel: string;
+    /** Thread ts to post into. Omit for flat replies (DMs). */
+    threadTs?: string;
+    /**
+     * Turn sender's Slack user id. `chat.startStream` requires it
+     * (`recipient_user_id`) when streaming into a channel; carried here so the
+     * native streamer can read it off the target.
+     */
+    recipientUserId?: string;
+    /**
+     * Inbound message ts used as the thread anchor for
+     * `assistant.threads.setStatus` in flat DMs (which have no `threadTs`).
+     * Replies still post flat; this only gives the native "is thinking…"
+     * indicator a thread to attach to.
+     */
+    statusTs?: string;
+}
+/**
+ * Assistant-pane behavior ("Agents & AI Apps"). The pane is ON by default —
+ * it activates whenever the Slack app config has the Agents toggle, and lies
+ * dormant otherwise. Pass an object to {@link SlackAdapterOptions.assistant} to
+ * customize, or `false` to disable pane handling entirely.
+ */
+export interface SlackAssistantOptions {
+    /** Posted when a user opens the pane. */
+    greeting?: string;
+    /** Up to 4 prompt chips shown on thread start. */
+    suggestedPrompts?: ReadonlyArray<{
+        title: string;
+        message: string;
+    }>;
+    /** "auto" (default): title the thread from the first user message. false: never title. */
+    title?: "auto" | false;
+    /** Native status shown under the composer while the agent runs. */
+    status?: {
+        /** Status while reasoning. Default "is thinking…". */
+        thinking?: string;
+        /** Up to 10 loading messages Slack rotates through. */
+        loadingMessages?: readonly string[];
+        /** Surface "is using `tool`…" per tool call. Default true. */
+        toolStatus?: boolean;
+    };
+}
+/**
+ * A 👍/👎 click on a streamed AI reply's native feedback row (Slack's
+ * `feedback_buttons` element, attached at `chat.stopStream`). Delivered to
+ * {@link SlackFeedbackOptions.onFeedback}.
+ */
+export interface SlackFeedback {
+    sentiment: "positive" | "negative";
+    /** The user who clicked, if Slack supplied their identity. */
+    user?: PlatformUser;
+    /** Channel (or DM) the reply lives in. */
+    channel: string;
+    /** Thread the reply belongs to, if any. */
+    threadTs?: string;
+    /** ts of the streamed reply message the feedback is about. */
+    messageTs: string;
+}
+/**
+ * Opt-in native AI feedback buttons. When provided, streamed replies on the
+ * native path finalize with a `context_actions` + `feedback_buttons` row, and
+ * clicks are routed to {@link onFeedback} (they never reach the engine's
+ * interaction dispatch). Omit to show no feedback row.
+ */
+export interface SlackFeedbackOptions {
+    /** Invoked when a user clicks 👍/👎 on a streamed reply. */
+    onFeedback: (feedback: SlackFeedback) => void | Promise<void>;
+    /** Positive button label. Default "Good response". */
+    positiveLabel?: string;
+    /** Negative button label. Default "Bad response". */
+    negativeLabel?: string;
+}
+export type SlackMentionReplyMode = "thread" | "channel";
+export type SlackThreadReplyMode = "mentionsOnly" | "afterBotReply";
+export interface SlackAppMentionOptions {
+    /**
+     * Where an app mention should reply. "thread" keeps channel noise down and is
+     * the default; "channel" posts a top-level channel reply.
+     */
+    reply?: SlackMentionReplyMode;
+}
+export interface SlackRespondToOptions {
+    /** Respond to normal Slack DMs (`message.im`). Default true. */
+    directMessages?: boolean;
+    /**
+     * Respond to Slack `app_mention` events in channels/private channels. Pass
+     * false to ignore app mentions entirely. Default: `{ reply: "thread" }`.
+     */
+    appMentions?: false | SlackAppMentionOptions;
+    /**
+     * How to handle plain, non-mention replies in channel/private-channel threads.
+     * "mentionsOnly" requires every thread turn to explicitly @mention the bot.
+     * "afterBotReply" preserves the legacy behavior: once the bot has replied in a
+     * thread, future plain replies in that thread can trigger new turns.
+     */
+    threadReplies?: SlackThreadReplyMode;
+}
+export interface ResolvedSlackRespondToOptions {
+    directMessages: boolean;
+    appMentions: false | {
+        reply: SlackMentionReplyMode;
+    };
+    threadReplies: SlackThreadReplyMode;
+}
+export declare const DEFAULT_SLACK_RESPOND_TO_OPTIONS: ResolvedSlackRespondToOptions;
+export declare function resolveSlackRespondToOptions(respondTo?: SlackRespondToOptions): ResolvedSlackRespondToOptions;
+/**
+ * Stable key identifying one ongoing conversation with the bot.
+ *
+ * - For a channel thread: `{ channelId, scope: <threadTs> }`
+ * - For a DM:             `{ channelId, scope: "dm" }`
+ *
+ * The store uses the pair as a string key; conversations from different
+ * channels never collide.
+ */
+export interface ConversationKey {
+    channelId: string;
+    scope: string;
+}
+/** Sentinel scope used for DMs (DMs are flat — no thread). */
+export declare const DM_SCOPE = "dm";
+/**
+ * What the listener emits per turn. Everything downstream of the listener
+ * works in terms of these — they don't know about Slack event shapes.
+ */
+export interface IncomingTurn {
+    conversation: ConversationKey;
+    replyTarget: ReplyTarget;
+    userText: string;
+    /**
+     * Slack user id of the person who sent this message (the requester).
+     * Surfaced to the agent so it can act on behalf of the right person —
+     * e.g. scope "my issues" to them, or assign created work to them.
+     * Absent only if the originating event carried no user (rare).
+     */
+    senderUserId?: string;
+    /**
+     * Stable per-delivery id for inbound idempotency. Prefer the Events API
+     * envelope `event_id` (survives Slack's retries), falling back to
+     * `client_msg_id` or `${channel}:${ts}`. Undefined when no stable id is
+     * available — the engine simply skips dedup for that event (never fabricate
+     * a random id; that would defeat dedup).
+     */
+    eventId?: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAEzD;;;GAGG;AACH,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,2DAA2D;IAC3D,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB;;;;OAIG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB;;;;;OAKG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;;;;GAKG;AACH,MAAM,WAAW,qBAAqB;IACpC,yCAAyC;IACzC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,kDAAkD;IAClD,gBAAgB,CAAC,EAAE,aAAa,CAAC;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACrE,0FAA0F;IAC1F,KAAK,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC;IACvB,mEAAmE;IACnE,MAAM,CAAC,EAAE;QACP,sDAAsD;QACtD,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,uDAAuD;QACvD,eAAe,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;QACpC,8DAA8D;QAC9D,UAAU,CAAC,EAAE,OAAO,CAAC;KACtB,CAAC;CACH;AAED;;;;GAIG;AACH,MAAM,WAAW,aAAa;IAC5B,SAAS,EAAE,UAAU,GAAG,UAAU,CAAC;IACnC,8DAA8D;IAC9D,IAAI,CAAC,EAAE,YAAY,CAAC;IACpB,0CAA0C;IAC1C,OAAO,EAAE,MAAM,CAAC;IAChB,2CAA2C;IAC3C,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,8DAA8D;IAC9D,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;;;;GAKG;AACH,MAAM,WAAW,oBAAoB;IACnC,4DAA4D;IAC5D,UAAU,EAAE,CAAC,QAAQ,EAAE,aAAa,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC9D,sDAAsD;IACtD,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,qDAAqD;IACrD,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,MAAM,qBAAqB,GAAG,QAAQ,GAAG,SAAS,CAAC;AAEzD,MAAM,MAAM,oBAAoB,GAAG,cAAc,GAAG,eAAe,CAAC;AAEpE,MAAM,WAAW,sBAAsB;IACrC;;;OAGG;IACH,KAAK,CAAC,EAAE,qBAAqB,CAAC;CAC/B;AAED,MAAM,WAAW,qBAAqB;IACpC,gEAAgE;IAChE,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB;;;OAGG;IACH,WAAW,CAAC,EAAE,KAAK,GAAG,sBAAsB,CAAC;IAC7C;;;;;OAKG;IACH,aAAa,CAAC,EAAE,oBAAoB,CAAC;CACtC;AAED,MAAM,WAAW,6BAA6B;IAC5C,cAAc,EAAE,OAAO,CAAC;IACxB,WAAW,EAAE,KAAK,GAAG;QAAE,KAAK,EAAE,qBAAqB,CAAA;KAAE,CAAC;IACtD,aAAa,EAAE,oBAAoB,CAAC;CACrC;AAED,eAAO,MAAM,gCAAgC,EAAE,6BAI9C,CAAC;AAEF,wBAAgB,4BAA4B,CAC1C,SAAS,CAAC,EAAE,qBAAqB,GAChC,6BAA6B,CAe/B;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,eAAe;IAC9B,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;CACf;AAED,8DAA8D;AAC9D,eAAO,MAAM,QAAQ,OAAO,CAAC;AAE7B;;;GAGG;AACH,MAAM,WAAW,YAAY;IAC3B,YAAY,EAAE,eAAe,CAAC;IAC9B,WAAW,EAAE,WAAW,CAAC;IACzB,QAAQ,EAAE,MAAM,CAAC;IACjB;;;;;OAKG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;;;;;OAMG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB"}

package/dist/types.js

@@ -0,0 +1,20 @@
+export const DEFAULT_SLACK_RESPOND_TO_OPTIONS = {
+    directMessages: true,
+    appMentions: { reply: "thread" },
+    threadReplies: "mentionsOnly",
+};
+export function resolveSlackRespondToOptions(respondTo) {
+    return {
+        directMessages: respondTo?.directMessages ??
+            DEFAULT_SLACK_RESPOND_TO_OPTIONS.directMessages,
+        appMentions: respondTo?.appMentions === false
+            ? false
+            : {
+                reply: respondTo?.appMentions?.reply ?? "thread",
+            },
+        threadReplies: respondTo?.threadReplies ??
+            DEFAULT_SLACK_RESPOND_TO_OPTIONS.threadReplies,
+    };
+}
+/** Sentinel scope used for DMs (DMs are flat — no thread). */
+export const DM_SCOPE = "dm";

package/package.json

@@ -0,0 +1,73 @@
+{
+  "name": "@copilotkit/channels-slack",
+  "version": "0.1.0",
+  "description": "Slack platform adapter for CopilotKit JSX channels (@copilotkit/channels).",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/CopilotKit/CopilotKit.git",
+    "directory": "packages/channels-slack"
+  },
+  "homepage": "https://github.com/CopilotKit/CopilotKit",
+  "keywords": [
+    "ai",
+    "agent",
+    "bot",
+    "slack",
+    "block-kit",
+    "socket-mode",
+    "copilotkit",
+    "ag-ui"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./codec": {
+      "types": "./dist/codec.d.ts",
+      "import": "./dist/codec.js"
+    },
+    "./render": {
+      "types": "./dist/render.d.ts",
+      "import": "./dist/render.js"
+    }
+  },
+  "dependencies": {
+    "@ag-ui/client": "0.0.57",
+    "@ag-ui/core": "0.0.57",
+    "@slack/bolt": "^4.2.0",
+    "@slack/types": "^2.21.1",
+    "@slack/web-api": "^7.16.0",
+    "rxjs": "^7.8.1",
+    "zod": "^3.25.76",
+    "zod-to-json-schema": "^3.25.1",
+    "@copilotkit/channels-ui": "~0.1.0",
+    "@copilotkit/core": "^1.62.3",
+    "@copilotkit/shared": "^1.62.3",
+    "@copilotkit/channels": "~0.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.0",
+    "typescript": "^5.6.3",
+    "vitest": "^4.1.3",
+    "@copilotkit/typescript-config": "^1.55.0-next.8"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "check-types": "tsc --noEmit -p tsconfig.json && tsc --noEmit -p tsconfig.check.json",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "publint": "publint .",
+    "attw": "attw --pack . --profile esm-only"
+  }
+}