@copilotkit/channels-slack 0.1.0

package/dist/ingress-normalize.js

@@ -0,0 +1,153 @@
+// Pure, Bolt-free Slack ingress semantics. Shared by the local Slack adapter's
+// Bolt listener AND the Intelligence-side webhook ingress (OSS-362), so the
+// platform-specific parsing (mention stripping, stable event-id derivation,
+// real-user-message filtering, field extraction) lives in ONE place instead of
+// being duplicated. No `@slack/bolt`, no Slack credentials, no network.
+//
+// What stays per-side (NOT here): response policy (respondTo), credentialed
+// thread-ownership reads (store.has), assistant-pane state, and building the
+// reply target / egress route. Each side wraps these pure helpers with its own
+// policy + transport.
+// Matches both the plain `<@U123>` form and Slack's labeled `<@U123|handle>`
+// form, so neither leaves a `|handle>` fragment behind after stripping.
+const MENTION_RE = /<@[UW][A-Z0-9]+(?:\|[^>]+)?>/g;
+/** Strip `<@U…>` / `<@U…|handle>` mention tokens and collapse whitespace. */
+export const stripMentions = (text) => text.replace(MENTION_RE, "").replace(/\s+/g, " ").trim();
+/**
+ * Derive a stable per-delivery id for inbound idempotency. Prefer the Events
+ * API envelope `event_id` (stable across Slack's automatic retries), then the
+ * message's `client_msg_id`, then a synthesized `${channel}:${ts}`. Returns
+ * undefined only when none is available — never fabricate a random id (that
+ * would defeat dedup).
+ */
+export function deriveEventId(body, event, channel) {
+    const envelopeEventId = body?.event_id;
+    if (envelopeEventId)
+        return envelopeEventId;
+    if (event.client_msg_id)
+        return event.client_msg_id;
+    if (event.ts)
+        return `${channel}:${event.ts}`;
+    return undefined;
+}
+/**
+ * Narrow to plain, user-authored, non-bot, non-subtyped messages with text.
+ * Rejects subtypes (edits/joins/…) except `file_share`, bot posts, and
+ * app-only messages. Anything that fails this is uninteresting to a bot.
+ */
+export function isPlainUserMessage(message, botUserId) {
+    if (!message || typeof message !== "object")
+        return false;
+    const m = message;
+    // Reject subtyped messages EXCEPT file uploads (`file_share`), which are real
+    // user messages carrying a `files` array we want to deliver.
+    if (m.subtype && m.subtype !== "file_share")
+        return false;
+    // Loop guard: skip the bot's own posts (matched by bot user id).
+    if (botUserId && m.user === botUserId)
+        return false;
+    // Skip messages with NO user (true bot-only / app-only posts). Messages
+    // posted via a USER token (xoxp-) belonging to an app have BOTH `user` and
+    // `bot_id` set — those are real user messages and should pass.
+    if (m.bot_id && !m.user)
+        return false;
+    if (typeof m.channel !== "string")
+        return false;
+    if (typeof m.text !== "string")
+        return false;
+    return true;
+}
+const hasFilesOn = (o) => Array.isArray(o?.files) &&
+    o.files.length > 0;
+/**
+ * Map a raw Slack payload (Events API envelope or slash-command body) to the
+ * platform-neutral ingress shape, or `undefined` when it isn't a turn/command
+ * worth delivering (bot echo, subtype, empty). The caller applies its own
+ * policy/entitlement gating and builds the reply route. First slice covers
+ * app_mention, direct/thread messages, and slash commands.
+ */
+export function normalizeSlackEvent(body, botUserId) {
+    // Slash command: a flat form body, no Events API `event`.
+    if (body.command) {
+        const channel = body.channel_id ?? "";
+        return {
+            kind: "command",
+            command: body.command,
+            text: (body.text ?? "").trim(),
+            channel,
+            senderUserId: body.user_id,
+            triggerId: body.trigger_id,
+            eventId: body.trigger_id
+                ? `${body.command}:${body.user_id}:${body.trigger_id}`
+                : undefined,
+        };
+    }
+    const event = body.event;
+    if (!event)
+        return undefined;
+    if (event.type === "app_mention") {
+        const channel = String(event.channel ?? "");
+        const userText = stripMentions(String(event.text ?? ""));
+        const hasFiles = hasFilesOn(event);
+        if (!userText && !hasFiles)
+            return undefined;
+        return {
+            kind: "turn",
+            source: "app_mention",
+            channel,
+            threadTs: event.thread_ts ?? event.ts,
+            ts: event.ts,
+            userText,
+            senderUserId: event.user,
+            eventId: deriveEventId(body, event, channel),
+            hasFiles,
+        };
+    }
+    if (event.type === "message") {
+        if (!isPlainUserMessage(event, botUserId))
+            return undefined;
+        const channel = event.channel;
+        const text = (event.text ?? "").trim();
+        const hasFiles = hasFilesOn(event);
+        if (!text && !hasFiles)
+            return undefined;
+        const isDM = event.channel_type === "im";
+        const eventId = deriveEventId(body, event, channel);
+        if (isDM) {
+            return {
+                kind: "turn",
+                source: "direct_message",
+                channel,
+                ts: event.ts,
+                // Strip mention tokens for parity with app_mention/thread_reply — a DM
+                // that @-mentions the bot shouldn't leak the raw `<@U…>` into userText.
+                userText: stripMentions(text),
+                senderUserId: event.user,
+                eventId,
+                hasFiles,
+            };
+        }
+        if (!event.thread_ts)
+            return undefined; // top-level channel chatter
+        // A threaded @-mention is delivered as BOTH an `app_mention` and this
+        // `message` event; app_mention handles it, so skip the duplicate here
+        // (mirrors the native Slack listener) to avoid a double response. Match
+        // both the plain `<@U…>` and labeled `<@U…|handle>` mention forms — same
+        // form set as MENTION_RE — so a labeled mention doesn't slip through.
+        if (botUserId &&
+            (text.includes(`<@${botUserId}>`) || text.includes(`<@${botUserId}|`))) {
+            return undefined;
+        }
+        return {
+            kind: "turn",
+            source: "thread_reply",
+            channel,
+            threadTs: event.thread_ts,
+            userText: stripMentions(text),
+            senderUserId: event.user,
+            eventId,
+            hasFiles,
+        };
+    }
+    return undefined;
+}

package/dist/ingress-normalize.test.d.ts

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

package/dist/ingress-normalize.test.d.ts.map

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

package/dist/ingress-normalize.test.js

@@ -0,0 +1,187 @@
+import { describe, it, expect } from "vitest";
+import { stripMentions, deriveEventId, isPlainUserMessage, normalizeSlackEvent, } from "./ingress-normalize.js";
+describe("stripMentions", () => {
+    it("strips <@U…> tokens and collapses whitespace", () => {
+        expect(stripMentions("<@U123>   hello   world")).toBe("hello world");
+        expect(stripMentions("<@W999> hi")).toBe("hi");
+        expect(stripMentions("<@U1>")).toBe("");
+    });
+    it("strips the labeled <@U…|handle> form without leaving a |handle> fragment", () => {
+        expect(stripMentions("<@U123|alice> hello")).toBe("hello");
+        expect(stripMentions("<@W999|Bob Smith> hi")).toBe("hi");
+        expect(stripMentions("<@U1|x>")).toBe("");
+    });
+});
+describe("deriveEventId", () => {
+    it("prefers the Events API envelope event_id", () => {
+        expect(deriveEventId({ event_id: "Ev1" }, { ts: "100.1" }, "C1")).toBe("Ev1");
+    });
+    it("falls back to client_msg_id, then channel:ts, then undefined", () => {
+        expect(deriveEventId({}, { client_msg_id: "cm1", ts: "100.1" }, "C1")).toBe("cm1");
+        expect(deriveEventId({}, { ts: "100.1" }, "C1")).toBe("C1:100.1");
+        expect(deriveEventId({}, {}, "C1")).toBeUndefined();
+    });
+});
+describe("isPlainUserMessage", () => {
+    it("accepts a plain user message", () => {
+        expect(isPlainUserMessage({ channel: "C1", text: "hi", user: "U1" }, "BOT")).toBe(true);
+    });
+    it("rejects subtypes (except file_share), bot echoes, and app-only posts", () => {
+        expect(isPlainUserMessage({ channel: "C1", text: "x", subtype: "channel_join" }, "BOT")).toBe(false);
+        expect(isPlainUserMessage({ channel: "C1", text: "x", user: "BOT" }, "BOT")).toBe(false);
+        expect(isPlainUserMessage({ channel: "C1", text: "x", bot_id: "B1" }, "BOT")).toBe(false);
+        expect(isPlainUserMessage({ channel: "C1", text: "x", subtype: "file_share", user: "U1" }, "BOT")).toBe(true);
+    });
+});
+describe("normalizeSlackEvent", () => {
+    it("maps an app_mention to a turn with stripped text + thread anchor", () => {
+        const n = normalizeSlackEvent({
+            event_id: "Ev1",
+            event: {
+                type: "app_mention",
+                channel: "C1",
+                text: "<@U1> hello",
+                user: "U2",
+                ts: "100.1",
+            },
+        });
+        expect(n).toEqual({
+            kind: "turn",
+            source: "app_mention",
+            channel: "C1",
+            threadTs: "100.1",
+            ts: "100.1",
+            userText: "hello",
+            senderUserId: "U2",
+            eventId: "Ev1",
+            hasFiles: false,
+        });
+    });
+    it("drops an empty mention with no files", () => {
+        expect(normalizeSlackEvent({
+            event: { type: "app_mention", channel: "C1", text: "<@U1>", ts: "1" },
+        })).toBeUndefined();
+    });
+    it("maps a DM message to a direct_message turn", () => {
+        const n = normalizeSlackEvent({
+            event_id: "Ev2",
+            event: {
+                type: "message",
+                channel: "D1",
+                channel_type: "im",
+                text: "hi there",
+                user: "U2",
+                ts: "100.2",
+            },
+        });
+        expect(n).toMatchObject({
+            kind: "turn",
+            source: "direct_message",
+            channel: "D1",
+            userText: "hi there",
+            ts: "100.2",
+        });
+    });
+    it("maps a threaded reply to a thread_reply turn with stripped text", () => {
+        const n = normalizeSlackEvent({
+            event: {
+                type: "message",
+                channel: "C1",
+                text: "<@U1> reply",
+                user: "U2",
+                ts: "100.3",
+                thread_ts: "100.0",
+            },
+        });
+        expect(n).toMatchObject({
+            kind: "turn",
+            source: "thread_reply",
+            threadTs: "100.0",
+            userText: "reply",
+        });
+    });
+    it("skips a threaded reply that @-mentions the bot (app_mention handles it — no double turn)", () => {
+        // Slack delivers a threaded @-mention as BOTH an app_mention and a
+        // message event; with the bot's own id known, the message branch must
+        // defer to app_mention so the managed path doesn't respond twice.
+        expect(normalizeSlackEvent({
+            event: {
+                type: "message",
+                channel: "C1",
+                text: "<@BOT> reply",
+                user: "U2",
+                ts: "100.4",
+                thread_ts: "100.0",
+            },
+        }, "BOT")).toBeUndefined();
+    });
+    it("skips a threaded reply that mentions the bot in the labeled <@U|handle> form", () => {
+        expect(normalizeSlackEvent({
+            event: {
+                type: "message",
+                channel: "C1",
+                text: "<@BOT|assistant> reply",
+                user: "U2",
+                ts: "100.7",
+                thread_ts: "100.0",
+            },
+        }, "BOT")).toBeUndefined();
+    });
+    it("still delivers a threaded reply that mentions a DIFFERENT user", () => {
+        expect(normalizeSlackEvent({
+            event: {
+                type: "message",
+                channel: "C1",
+                text: "<@U9> reply",
+                user: "U2",
+                ts: "100.5",
+                thread_ts: "100.0",
+            },
+        }, "BOT")).toMatchObject({ source: "thread_reply", userText: "reply" });
+    });
+    it("strips mention tokens from a DM turn (parity with app_mention/thread_reply)", () => {
+        const n = normalizeSlackEvent({
+            event: {
+                type: "message",
+                channel: "D1",
+                channel_type: "im",
+                text: "<@U1> hi there",
+                user: "U2",
+                ts: "100.6",
+            },
+        });
+        expect(n).toMatchObject({ source: "direct_message", userText: "hi there" });
+    });
+    it("drops top-level channel chatter (no thread_ts) and bot echoes", () => {
+        expect(normalizeSlackEvent({
+            event: {
+                type: "message",
+                channel: "C1",
+                text: "hi",
+                user: "U2",
+                ts: "1",
+            },
+        })).toBeUndefined();
+        expect(normalizeSlackEvent({
+            event: { type: "message", channel: "C1", text: "x", bot_id: "B1" },
+        })).toBeUndefined();
+    });
+    it("maps a slash command", () => {
+        const n = normalizeSlackEvent({
+            command: "/triage",
+            text: "now",
+            channel_id: "C1",
+            user_id: "U2",
+            trigger_id: "T1",
+        });
+        expect(n).toEqual({
+            kind: "command",
+            command: "/triage",
+            text: "now",
+            channel: "C1",
+            senderUserId: "U2",
+            triggerId: "T1",
+            eventId: "/triage:U2:T1",
+        });
+    });
+});

package/dist/interaction.d.ts

@@ -0,0 +1,30 @@
+import type { InteractionEvent, IncomingReaction, IncomingModalSubmit, IncomingModalClose } from "@copilotkit/channels";
+import type { ConversationKey } from "./types.js";
+/**
+ * Stable string key shared by ingress (onTurn) and interaction decoding so the
+ * bot's awaitChoice waiters resolve. Both paths MUST derive the conversation key
+ * from this single helper — a mismatch silently strands the waiter.
+ */
+export declare function conversationKeyOf(key: ConversationKey): string;
+/**
+ * Decode a Slack `block_actions` payload into a bot `InteractionEvent`.
+ *
+ * Carries ONLY the opaque minted action id (`ck:...`) plus the tiny, non-sensitive
+ * button/option value — there is NO resume-data smuggling through the payload.
+ * Durability rides on the ActionStore keyed by that opaque id, not on what Slack
+ * round-trips back to us.
+ */
+export declare function decodeInteraction(raw: unknown): InteractionEvent | undefined;
+/** Decode a Slack `reaction_added`/`reaction_removed` event into an `IncomingReaction`. */
+export declare function decodeReaction(event: unknown, added: boolean): IncomingReaction | undefined;
+/** Decode a Slack `view_submission` payload into an `IncomingModalSubmit`. */
+export declare function decodeViewSubmission(view: unknown, user?: {
+    id: string;
+    name?: string;
+}): IncomingModalSubmit;
+/** Decode a Slack `view_closed` payload into an `IncomingModalClose`. */
+export declare function decodeViewClosed(view: unknown, user?: {
+    id: string;
+    name?: string;
+}): IncomingModalClose;
+//# sourceMappingURL=interaction.d.ts.map

package/dist/interaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interaction.d.ts","sourceRoot":"","sources":["../src/interaction.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,gBAAgB,EAChB,gBAAgB,EAChB,mBAAmB,EACnB,kBAAkB,EACnB,MAAM,sBAAsB,CAAC;AAE9B,OAAO,KAAK,EAAE,eAAe,EAAe,MAAM,YAAY,CAAC;AAE/D;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,eAAe,GAAG,MAAM,CAE9D;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,OAAO,GAAG,gBAAgB,GAAG,SAAS,CA2F5E;AAkBD,2FAA2F;AAC3F,wBAAgB,cAAc,CAC5B,KAAK,EAAE,OAAO,EACd,KAAK,EAAE,OAAO,GACb,gBAAgB,GAAG,SAAS,CAgC9B;AAgGD,8EAA8E;AAC9E,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,OAAO,EACb,IAAI,CAAC,EAAE;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,GACnC,mBAAmB,CAarB;AAED,yEAAyE;AACzE,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,OAAO,EACb,IAAI,CAAC,EAAE;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,GACnC,kBAAkB,CAYpB"}

package/dist/interaction.js

@@ -0,0 +1,219 @@
+import { DM_SCOPE } from "./types.js";
+/**
+ * Stable string key shared by ingress (onTurn) and interaction decoding so the
+ * bot's awaitChoice waiters resolve. Both paths MUST derive the conversation key
+ * from this single helper — a mismatch silently strands the waiter.
+ */
+export function conversationKeyOf(key) {
+    return `${key.channelId}::${key.scope}`;
+}
+/**
+ * Decode a Slack `block_actions` payload into a bot `InteractionEvent`.
+ *
+ * Carries ONLY the opaque minted action id (`ck:...`) plus the tiny, non-sensitive
+ * button/option value — there is NO resume-data smuggling through the payload.
+ * Durability rides on the ActionStore keyed by that opaque id, not on what Slack
+ * round-trips back to us.
+ */
+export function decodeInteraction(raw) {
+    const body = raw;
+    if (body.type !== "block_actions")
+        return undefined;
+    const action = body.actions?.[0];
+    if (!action?.action_id)
+        return undefined;
+    const channelId = body.channel?.id ?? body.container?.channel_id;
+    if (!channelId)
+        return undefined;
+    // An EXPLICIT thread ts means the click happened inside a thread — including
+    // an assistant-pane DM, which is threaded even though its channel id starts
+    // with "D". Only fall back to the message's own ts (a thread root) for the
+    // scope, never conflate the two.
+    const explicitThreadTs = body.message?.thread_ts ?? body.container?.thread_ts;
+    const threadTs = explicitThreadTs ?? body.message?.ts ?? body.container?.message_ts;
+    const isDm = channelId.startsWith("D");
+    // Scope MUST match what the listener emits per turn (see assistant.ts /
+    // adapter.ts), or the HITL `awaitChoice` waiter is stranded and the run
+    // never resumes: the thread ts for ANY threaded conversation (assistant-pane
+    // DMs included), and DM_SCOPE only for a genuinely unthreaded DM.
+    const scope = explicitThreadTs
+        ? explicitThreadTs
+        : isDm
+            ? DM_SCOPE
+            : (threadTs ?? "");
+    const conversationKey = conversationKeyOf({ channelId, scope });
+    const replyTarget = {
+        channel: channelId,
+        threadTs: isDm && !explicitThreadTs ? undefined : threadTs,
+    };
+    // Tiny, non-sensitive value: the clicked button's value (or selected option
+    // value), JSON-parsed if it round-trips, otherwise the raw string. A
+    // multi_static_select reports `selected_options` (an array) → a `string[]`.
+    let value;
+    if (action.selected_options) {
+        value = action.selected_options.map((o) => parseValue(o.value));
+    }
+    else {
+        value = parseValue(action.value ?? action.selected_option?.value);
+    }
+    const user = body.user?.id
+        ? { id: body.user.id, name: body.user.name ?? body.user.username }
+        : undefined;
+    // The picker message's ts: an onClick `thread.update(message.ref, …)`
+    // targets this message in place (the adapter's `update` reads `channel`
+    // off the ref).
+    const messageTs = body.message?.ts ?? body.container?.message_ts;
+    const messageRef = messageTs
+        ? { id: messageTs, channel: channelId }
+        : undefined;
+    // Stable per-click id for inbound dedup: the channel + picker message ts +
+    // the action's own ts uniquely identify one click. Fall back to trigger_id
+    // (single-use per interaction) when those refs are absent. Undefined only if
+    // neither is available — never fabricate (that would defeat dedup).
+    const eventId = channelId && messageTs && action.action_ts
+        ? `${channelId}:${messageTs}:${action.action_ts}`
+        : body.trigger_id;
+    return {
+        id: action.action_id,
+        conversationKey,
+        replyTarget,
+        value,
+        user,
+        messageRef,
+        triggerId: body.trigger_id,
+        eventId,
+    };
+}
+/** JSON-parse a control value so non-string option values round-trip; else keep the raw string. */
+function parseValue(raw) {
+    if (typeof raw !== "string")
+        return raw;
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return raw;
+    }
+}
+/** Decode a Slack `reaction_added`/`reaction_removed` event into an `IncomingReaction`. */
+export function decodeReaction(event, added) {
+    const e = event;
+    if (e.item?.type !== "message")
+        return undefined;
+    const channel = e.item.channel;
+    const ts = e.item.ts;
+    if (!channel || !ts || !e.reaction)
+        return undefined;
+    const scope = channel.startsWith("D") ? DM_SCOPE : ts;
+    return {
+        rawEmoji: e.reaction,
+        added,
+        user: e.user ? { id: e.user } : undefined,
+        conversationKey: conversationKeyOf({ channelId: channel, scope }),
+        // Thread the reply under the reacted message (channel/thread reactions);
+        // DMs stay flat. A handler replying via thread.post/runAgent must land
+        // under the reacted message, not at the channel root. Carry the reactor id
+        // as `recipientUserId` (parity with onTurn): `chat.startStream` REQUIRES
+        // `recipient_user_id` when streaming to a channel, so without it the
+        // adapter's first native channel stream for this target fails — and the
+        // adapter then flips its own `nativeStreamingOk` to false, downgrading the
+        // whole workspace to the legacy transport.
+        replyTarget: {
+            channel,
+            ...(scope === DM_SCOPE ? {} : { threadTs: ts }),
+            ...(e.user ? { recipientUserId: e.user } : {}),
+        },
+        messageId: ts,
+        // Update-capable ref (channel + ts) so an onReaction handler can swap the
+        // reacted message's UI in place via thread.update.
+        messageRef: { id: ts, channel },
+        threadId: ts,
+        raw: event,
+    };
+}
+/**
+ * Flatten a Slack view's `state.values` to a flat `fieldId → value` map. The
+ * modal vocabulary names every block id == action id (the field id), so for
+ * each block we take the inner element keyed by that same block id, falling
+ * back to the first element. Text inputs expose `value`; selects/radios expose
+ * `selected_option.value`.
+ */
+function flattenViewValues(view) {
+    const out = {};
+    const values = view.state?.values ?? {};
+    for (const blockId of Object.keys(values)) {
+        const inner = values[blockId];
+        const el = inner[blockId] ?? Object.values(inner)[0];
+        if (!el)
+            continue;
+        out[blockId] = el.value ?? el.selected_option?.value;
+    }
+    return out;
+}
+/**
+ * Decode a view's `private_metadata` into the conversation context + the
+ * author's original metadata. When the string is a `__cpk` envelope (stamped at
+ * open time), return the derived `conversationKey`/`replyTarget` and restore the
+ * author's `pm`. Otherwise (absent, non-JSON, or a plain author string from a
+ * modal opened some other way) preserve back-compat: pass the raw string
+ * through as `privateMetadata`, with no conversationKey/replyTarget.
+ */
+function decodeModalContext(privateMetadata) {
+    if (privateMetadata === undefined)
+        return {};
+    let parsed;
+    try {
+        parsed = JSON.parse(privateMetadata);
+    }
+    catch {
+        // Non-JSON string → treat as a plain author privateMetadata.
+        return { privateMetadata };
+    }
+    if (!parsed ||
+        typeof parsed !== "object" ||
+        typeof parsed.__cpk !== "object" ||
+        parsed.__cpk === null ||
+        typeof parsed.__cpk.channel !== "string") {
+        // Valid JSON but not our envelope → treat the original string as plain
+        // author metadata (e.g. a modal opened with a JSON private_metadata).
+        return { privateMetadata };
+    }
+    const env = parsed;
+    const channelId = env.__cpk.channel;
+    const threadTs = env.__cpk.threadTs;
+    const scope = threadTs ?? DM_SCOPE;
+    return {
+        conversationKey: conversationKeyOf({ channelId, scope }),
+        replyTarget: { channel: channelId, ...(threadTs ? { threadTs } : {}) },
+        privateMetadata: env.pm,
+    };
+}
+/** Decode a Slack `view_submission` payload into an `IncomingModalSubmit`. */
+export function decodeViewSubmission(view, user) {
+    const v = view;
+    const ctx = decodeModalContext(v.private_metadata);
+    return {
+        callbackId: v.callback_id ?? "",
+        values: flattenViewValues(v),
+        user,
+        privateMetadata: ctx.privateMetadata,
+        ...(ctx.conversationKey ? { conversationKey: ctx.conversationKey } : {}),
+        ...(ctx.replyTarget ? { replyTarget: ctx.replyTarget } : {}),
+        platform: "slack",
+        raw: view,
+    };
+}
+/** Decode a Slack `view_closed` payload into an `IncomingModalClose`. */
+export function decodeViewClosed(view, user) {
+    const v = view;
+    const ctx = decodeModalContext(v.private_metadata);
+    return {
+        callbackId: v.callback_id ?? "",
+        user,
+        privateMetadata: ctx.privateMetadata,
+        ...(ctx.conversationKey ? { conversationKey: ctx.conversationKey } : {}),
+        ...(ctx.replyTarget ? { replyTarget: ctx.replyTarget } : {}),
+        platform: "slack",
+        raw: view,
+    };
+}

package/dist/interaction.test.d.ts

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

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

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