@copilotkit/channels-slack 0.1.0

package/dist/event-renderer.js

@@ -0,0 +1,493 @@
+import { ChunkedMessageStream } from "./chunked-message-stream.js";
+import { markdownToMrkdwn } from "./markdown-to-mrkdwn.js";
+import { autoCloseOpenMarkdown } from "./auto-close-streaming.js";
+import { NativeMessageStream } from "./native-stream.js";
+const DEFAULT_THINKING_STATUS = "is thinking…";
+/**
+ * The display-transform applied to every streaming chunk before it hits
+ * `chat.update` (the LEGACY transport only — the native path streams raw
+ * markdown). Composed of two pure functions:
+ *
+ *   1. `autoCloseOpenMarkdown` — closes dangling fenced code, inline
+ *      backticks, bold/italic/strike so a mid-stream buffer renders as
+ *      valid mrkdwn (instead of leaking code-styling through the rest of
+ *      the Slack message). When the agent eventually emits the real
+ *      close marker the buffer becomes balanced and this step adds
+ *      nothing, so the committed Slack message is never double-closed.
+ *
+ *   2. `markdownToMrkdwn` — translates the (now-balanced) markdown into
+ *      Slack mrkdwn.
+ */
+const displayTransform = (text) => markdownToMrkdwn(autoCloseOpenMarkdown(text));
+const INTERRUPTED_SUFFIX = "\n_(interrupted)_";
+/**
+ * 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 function createRunRenderer(args) {
+    const { transport, target } = args;
+    const interruptEventNames = args.interruptEventNames ?? new Set(["on_interrupt"]);
+    const showToolStatus = args.showToolStatus ?? true;
+    const nativeMode = args.nativeStreaming !== undefined;
+    // ── Native status mode ──────────────────────────────────────────────
+    // Whenever the reply is anchored to a thread, the run lifecycle drives
+    // Slack's native `assistant.threads.setStatus` ("is thinking…") instead of a
+    // placeholder message. `isPane` only selects how *tool* progress is shown.
+    const status = args.status;
+    const statusMode = status !== undefined;
+    const isPane = status?.isPane ?? false;
+    const paneToolStatus = status?.config?.toolStatus ?? true;
+    const setStatus = async (text) => {
+        if (!status)
+            return;
+        try {
+            await transport.setStatus({
+                channel_id: target.channel,
+                thread_ts: status.threadTs,
+                status: text,
+                ...(text && status.config?.loadingMessages
+                    ? { loading_messages: [...status.config.loadingMessages] }
+                    : {}),
+            });
+        }
+        catch (err) {
+            console.error("[slack-renderer] setStatus failed:", err);
+        }
+    };
+    /** Clear the native status (best-effort). */
+    const clearStatus = async () => {
+        if (!statusMode)
+            return;
+        await setStatus("");
+    };
+    /** Whether this run has posted any visible reply yet (drives status clear). */
+    let postedReply = false;
+    const onFirstReply = async () => {
+        if (postedReply)
+            return;
+        postedReply = true;
+        // Slack auto-clears status when the app replies; clear explicitly too so
+        // there's no lingering indicator on slow/edge paths.
+        await clearStatus();
+    };
+    // ── Legacy per-message streaming state ──────────────────────────────
+    /** Per-AG-UI-message accumulated text (legacy path; native uses one buffer). */
+    const buffers = new Map();
+    /** Per-AG-UI-message text stream (legacy). Lazily created on first content. */
+    const streams = new Map();
+    /** Per-tool-call Slack message ts so we can edit it on END (legacy/degraded). */
+    const toolStatusTs = new Map();
+    /**
+     * Once a stream has been "finalised" (either via TEXT_MESSAGE_END or via
+     * markInterrupted), we drop it. Late-arriving events for the same
+     * messageId are ignored — they'd otherwise reopen a closed stream and
+     * post a fresh placeholder *after* the user already saw the message
+     * was over.
+     */
+    const finalised = new Set();
+    // ── Native turn-scoped streaming state ──────────────────────────────
+    /** The single native stream for the whole turn (lazily created). */
+    let turnStream;
+    /** All text streamed this turn (every AG-UI message concatenated). */
+    let turnText = "";
+    /** Set after a TEXT_MESSAGE_END so the next message inserts a blank-line gap. */
+    let pendingSeparator = false;
+    /** True once the turn stream has been finalized (interrupt / error / finish). */
+    let turnFinalised = false;
+    /**
+     * Whether native structured chunks (`task_update`) are usable. Flipped off
+     * the first time a chunk append fails (old workspace / missing scope), after
+     * which tool progress degrades to `:wrench:` rows.
+     */
+    let taskChunksOk = nativeMode && (args.nativeStreaming?.taskChunks ?? true);
+    /**
+     * Set when the caller intentionally aborted the run (i.e. a new turn
+     * arrived for the same conversation). Suppresses the RUN_ERROR /
+     * AbortError warning and stops accepting further AG-UI events — the
+     * `_(interrupted)_` marker conveys the state visually.
+     */
+    let aborted = false;
+    /** Tool calls observed in this run, in event order. */
+    const capturedToolCalls = [];
+    /**
+     * Interrupt observed via a matching `onCustomEvent`. The React
+     * `useInterrupt` pattern buffers locally and commits on run-finalize,
+     * which we mirror via this single-slot variable — the run-loop reads it
+     * after `runAgent` resolves.
+     */
+    let pendingInterrupt;
+    // The shipped chat.update streamer (mrkdwn-translated). Also the automatic
+    // fallback for the native transport.
+    const makeLegacyStream = () => new ChunkedMessageStream({
+        postPlaceholder: async (text) => {
+            const posted = await transport.postMessage({
+                channel: target.channel,
+                thread_ts: target.threadTs,
+                text,
+            });
+            if (!posted.ts)
+                throw new Error("postMessage returned no ts");
+            await onFirstReply();
+            return posted.ts;
+        },
+        updateAt: async (ts, text) => {
+            await transport.updateMessage({ channel: target.channel, ts, text });
+        },
+        transform: displayTransform,
+    });
+    // The single native turn stream — raw markdown, no mrkdwn translation, with
+    // interleaved `task_update` chunks.
+    const ensureTurnStream = () => {
+        if (turnStream)
+            return turnStream;
+        const ns = args.nativeStreaming;
+        turnStream = new NativeMessageStream({
+            transport: {
+                startStream: async () => {
+                    const ts = await ns.transport.startStream();
+                    // The native message owns the bubble now; clear the native status
+                    // (the reply is visible).
+                    await onFirstReply();
+                    return ts;
+                },
+                appendText: (ts, md) => ns.transport.appendText(ts, md),
+                appendChunks: (ts, chunks) => ns.transport.appendChunks(ts, chunks),
+                stopStream: (ts, blocks) => ns.transport.stopStream(ts, blocks),
+            },
+            fallback: makeLegacyStream,
+            onStartFailure: ns.onStartFailure,
+            onChunkFailure: () => {
+                // Structured chunks unsupported on this workspace — degrade tool
+                // progress to `:wrench:` rows for the rest of the run, and let the
+                // adapter persist it so later turns skip chunks entirely.
+                taskChunksOk = false;
+                ns.onChunkFailure?.();
+            },
+        });
+        return turnStream;
+    };
+    const ensureLegacyStream = (messageId) => {
+        if (finalised.has(messageId))
+            return undefined;
+        let s = streams.get(messageId);
+        if (!s) {
+            s = makeLegacyStream();
+            streams.set(messageId, s);
+        }
+        return s;
+    };
+    const captureToolCall = (toolCallId, toolCallName, toolCallArgs) => {
+        const existing = capturedToolCalls.find((c) => c.toolCallId === toolCallId);
+        if (existing) {
+            existing.toolCallName = toolCallName;
+            existing.toolCallArgs = toolCallArgs;
+        }
+        else {
+            capturedToolCalls.push({ toolCallId, toolCallName, toolCallArgs });
+        }
+    };
+    /** Post a `:wrench:` tool-start row (legacy path / native degradation). */
+    const postToolStartRow = async (toolCallId, toolCallName) => {
+        if (!showToolStatus)
+            return;
+        if (toolStatusTs.has(toolCallId))
+            return; // dedup
+        try {
+            const posted = await transport.postMessage({
+                channel: target.channel,
+                thread_ts: target.threadTs,
+                text: `:wrench: Calling \`${toolCallName}\`…`,
+            });
+            if (posted.ts)
+                toolStatusTs.set(toolCallId, posted.ts);
+        }
+        catch (err) {
+            console.error("[slack-renderer] tool-start post failed:", err);
+        }
+    };
+    /** Edit the `:wrench:` row to a checkmark on END (legacy path / native degradation). */
+    const finishToolStatusRow = async (toolCallId, toolCallName) => {
+        if (!showToolStatus)
+            return;
+        const ts = toolStatusTs.get(toolCallId);
+        if (!ts)
+            return;
+        try {
+            await transport.updateMessage({
+                channel: target.channel,
+                ts,
+                text: `:white_check_mark: \`${toolCallName}\``,
+            });
+        }
+        catch (err) {
+            console.error("[slack-renderer] tool-end update failed:", err);
+        }
+        toolStatusTs.delete(toolCallId);
+    };
+    const subscriber = {
+        // ── 0. Run lifecycle: thinking indicator ───────────────────────────
+        async onRunStartedEvent() {
+            if (aborted)
+                return;
+            // Native "is thinking…" status on the thread. `runAgent` fires once per
+            // tool-loop iteration, so we (re)set it on each RUN_STARTED — Slack also
+            // resets its 2-minute status timeout on each call.
+            if (statusMode) {
+                await setStatus(status?.config?.thinking || DEFAULT_THINKING_STATUS);
+            }
+        },
+        async onRunFinishedEvent() {
+            // The NATIVE turn stream is NOT finalized here: the run-loop may
+            // re-invoke for tool results, so it stays open and is finalized in
+            // `finish()`. For the LEGACY per-message path, defensively finalize any
+            // stream still open at the end of THIS run so its text is fully posted
+            // before the run-loop executes tool handlers that post out-of-band
+            // content (images/cards). In native mode `streams` is empty, so this
+            // loop is a no-op.
+            const drains = [];
+            for (const [id, stream] of Array.from(streams.entries())) {
+                drains.push(stream.finish());
+                streams.delete(id);
+                finalised.add(id);
+                buffers.delete(id);
+            }
+            if (drains.length > 0)
+                await Promise.all(drains);
+            // A posted reply auto-clears Slack's status; clear it explicitly when the
+            // run produced no visible reply yet (tool/component/HITL output, or none).
+            if (statusMode && !postedReply)
+                await clearStatus();
+        },
+        // ── 1. Text streaming ──────────────────────────────────────────────
+        onTextMessageStartEvent({ event }) {
+            if (aborted)
+                return;
+            if (nativeMode) {
+                // A new message after prior text → blank-line gap in the one bubble.
+                if (turnText.length > 0)
+                    pendingSeparator = true;
+                return;
+            }
+            buffers.set(event.messageId, "");
+        },
+        onTextMessageContentEvent({ event }) {
+            if (aborted)
+                return;
+            const delta = event.delta ?? "";
+            if (nativeMode) {
+                if (turnFinalised)
+                    return;
+                if (pendingSeparator && turnText.length > 0) {
+                    turnText += "\n\n";
+                    pendingSeparator = false;
+                }
+                turnText += delta;
+                ensureTurnStream().append(turnText);
+                return;
+            }
+            const next = (buffers.get(event.messageId) ?? "") + delta;
+            buffers.set(event.messageId, next);
+            ensureLegacyStream(event.messageId)?.append(next);
+        },
+        async onTextMessageEndEvent({ event }) {
+            if (aborted)
+                return;
+            if (nativeMode) {
+                // Do NOT finish the turn stream — more messages / tools may follow.
+                // The blank-line separator is applied on the next message's first
+                // content. Finalization happens in `finish()`.
+                return;
+            }
+            const stream = streams.get(event.messageId);
+            if (stream) {
+                await stream.finish();
+                streams.delete(event.messageId);
+            }
+            buffers.delete(event.messageId);
+            finalised.add(event.messageId);
+        },
+        // ── 2. Tool-call surfacing + capture ──────────────────────────────
+        async onToolCallStartEvent({ event }) {
+            if (aborted)
+                return;
+            // Composer "is using `tool`…" status on ANY thread anchor (not just
+            // panes) — the native status API works on every surface. Each setStatus
+            // also resets Slack's status timeout. The pane's `toolStatus` config knob
+            // still gates panes; every other surface shows it when tool status is on.
+            if (statusMode && showToolStatus && (isPane ? paneToolStatus : true)) {
+                await setStatus(`is using \`${event.toolCallName}\`…`);
+            }
+            // Panes surface tool activity ONLY as composer status — no in-thread rows.
+            if (isPane)
+                return;
+            // Native path: also surface the call as an in-message `task_update` chunk.
+            if (nativeMode && taskChunksOk) {
+                if (showToolStatus) {
+                    ensureTurnStream().appendChunk({
+                        type: "task_update",
+                        id: event.toolCallId,
+                        title: `Using \`${event.toolCallName}\``,
+                        status: "in_progress",
+                    });
+                }
+                return;
+            }
+            // Legacy path (or native degraded): a `:wrench:` status row.
+            await postToolStartRow(event.toolCallId, event.toolCallName);
+        },
+        onToolCallArgsEvent({ event, toolCallName, partialToolCallArgs }) {
+            if (aborted)
+                return;
+            // Accumulate partial args so the captured entry tracks the latest
+            // parsed shape as args stream in. We keep a single entry per
+            // toolCallId, overwriting `toolCallArgs`.
+            captureToolCall(event.toolCallId, toolCallName, (partialToolCallArgs ?? {}));
+        },
+        async onToolCallEndEvent({ event, toolCallName, toolCallArgs }) {
+            if (aborted)
+                return;
+            // Capture EVERY tool call — the run-loop filters by which tools are
+            // registered. A tool with no `args` events still lands here.
+            captureToolCall(event.toolCallId, toolCallName, (toolCallArgs ?? {}));
+            // Pane threads use live status (set on START); no per-call rows to edit.
+            if (isPane)
+                return;
+            // Native path: complete the in-message `task_update`.
+            if (nativeMode && taskChunksOk) {
+                if (showToolStatus) {
+                    ensureTurnStream().appendChunk({
+                        type: "task_update",
+                        id: event.toolCallId,
+                        title: `Used \`${toolCallName}\``,
+                        status: "complete",
+                    });
+                }
+                return;
+            }
+            // Legacy path (or native degraded): edit the `:wrench:` row to a check.
+            await finishToolStatusRow(event.toolCallId, toolCallName);
+        },
+        // ── 3. Interrupts (LangGraph `interrupt()` → AG-UI custom event) ─
+        onCustomEvent({ event }) {
+            if (aborted)
+                return;
+            const e = event;
+            if (!e.name || !interruptEventNames.has(e.name))
+                return;
+            // LangGraph's AG-UI adapter ships the interrupt value as a JSON
+            // string in some shapes (and as an object in others). Normalize
+            // here so downstream schema validation always sees the parsed shape.
+            let value = e.value;
+            if (typeof value === "string") {
+                try {
+                    value = JSON.parse(value);
+                }
+                catch {
+                    // Leave it as a string — the handler's schema will reject it
+                    // explicitly with a clearer error.
+                }
+            }
+            pendingInterrupt = { eventName: e.name, value };
+        },
+        // ── 4. Errors ─────────────────────────────────────────────────────
+        async onRunErrorEvent({ event }) {
+            // Don't post a warning if we're the ones aborting the run; the
+            // `_(interrupted)_` marker on the partial reply is the user-visible
+            // signal in that case.
+            if (statusMode)
+                await clearStatus();
+            // Close any open native turn stream so the partial reply is committed.
+            await finalizeTurnStream();
+            if (aborted)
+                return;
+            try {
+                await transport.postMessage({
+                    channel: target.channel,
+                    thread_ts: target.threadTs,
+                    text: `:warning: Agent error: ${event.message ?? "unknown error"}`,
+                });
+            }
+            catch (err) {
+                console.error("[slack-renderer] error notice failed:", err);
+            }
+        },
+    };
+    /** Finalize the native turn stream once (idempotent), attaching feedback if any. */
+    const finalizeTurnStream = async () => {
+        if (turnFinalised)
+            return;
+        turnFinalised = true;
+        if (turnStream) {
+            // Attach the feedback row only to a COMPLETE reply that streamed text —
+            // never to an interrupted/aborted partial (no point rating a half answer).
+            const blocks = !aborted && turnText.length > 0 ? args.feedbackBlocks : undefined;
+            await turnStream.finish(blocks);
+        }
+    };
+    return {
+        subscriber,
+        getCapturedToolCalls: () => capturedToolCalls,
+        getPendingInterrupt: () => pendingInterrupt,
+        clearPendingInterrupt: () => {
+            pendingInterrupt = undefined;
+        },
+        async finish() {
+            // Turn-end hook (called by the engine after the run-loop resolves).
+            // No-op if the run was interrupted (markInterrupted already drained).
+            if (aborted)
+                return;
+            await finalizeTurnStream();
+        },
+        async markInterrupted() {
+            // Idempotent. Mark BEFORE any await so subsequent subscriber
+            // callbacks (including the RUN_ERROR that AG-UI fires when we
+            // abort) see the flag and bail.
+            if (aborted)
+                return;
+            aborted = true;
+            // Clear the native status; the interrupted marker (or the next turn) is
+            // the user-visible signal now.
+            if (statusMode)
+                await clearStatus();
+            // Native turn stream: append the interrupted marker to the partial reply
+            // and finalize it.
+            if (nativeMode) {
+                if (turnStream && turnText.length > 0 && !turnFinalised) {
+                    turnStream.append(turnText + INTERRUPTED_SUFFIX);
+                }
+                await finalizeTurnStream();
+            }
+            // Legacy per-message streams: append the marker and drain. Streams with
+            // no content yet are silently dropped (the bot never posted anything).
+            const tasks = [];
+            for (const [id, stream] of Array.from(streams.entries())) {
+                const buf = buffers.get(id) ?? "";
+                if (buf.length > 0) {
+                    stream.append(buf + INTERRUPTED_SUFFIX);
+                    tasks.push(stream.finish());
+                }
+                streams.delete(id);
+                finalised.add(id);
+            }
+            buffers.clear();
+            await Promise.all(tasks);
+        },
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,34 @@
+export { SlackConversationStore } from "./conversation-store.js";
+export type { AgentSession } from "./conversation-store.js";
+export { slackCodec } from "./codec.js";
+export { normalizeSlackEvent, stripMentions, deriveEventId, isPlainUserMessage, } from "./ingress-normalize.js";
+export type { SlackNeutralEvent, PlainUserMessage, } from "./ingress-normalize.js";
+export type { ConversationKey, IncomingTurn, ResolvedSlackRespondToOptions, ReplyTarget, SlackAssistantOptions, SlackAppMentionOptions, SlackFeedback, SlackFeedbackOptions, SlackMentionReplyMode, SlackRespondToOptions, SlackThreadReplyMode, } from "./types.js";
+export { DEFAULT_SLACK_RESPOND_TO_OPTIONS, DM_SCOPE, resolveSlackRespondToOptions, } from "./types.js";
+export { MessageStream } from "./message-stream.js";
+export type { MessageStreamConfig } from "./message-stream.js";
+export { ChunkedMessageStream } from "./chunked-message-stream.js";
+export type { ChunkedMessageStreamConfig } from "./chunked-message-stream.js";
+export { NativeMessageStream } from "./native-stream.js";
+export type { NativeMessageStreamConfig, NativeStreamTransport, TextStream, } from "./native-stream.js";
+export { attachAssistant } from "./assistant.js";
+export type { AttachAssistantConfig, AssistantHandle } from "./assistant.js";
+export { autoCloseOpenMarkdown, detectOpenContext, renderContextOpener, } from "./auto-close-streaming.js";
+export type { OpenMarkdownContext } from "./auto-close-streaming.js";
+export { markdownToMrkdwn } from "./markdown-to-mrkdwn.js";
+export { attachSlackListener } from "./slack-listener.js";
+export type { ListenerConfig, TurnHandler } from "./slack-listener.js";
+export { slackTaggingContext, slackFormattingContext, slackConversationModelContext, defaultSlackContext, } from "./built-in-context.js";
+export { SanitizingHttpAgent } from "./sanitizing-http-agent.js";
+export { buildFileContentParts } from "./download-files.js";
+export type { SlackFileRef, AgentContentPart, FileDeliveryConfig, } from "./download-files.js";
+export { lookupSlackUserTool, defaultSlackTools } from "./built-in-tools.js";
+export { slack, SlackAdapter } from "./adapter.js";
+export type { SlackAdapterOptions } from "./adapter.js";
+export { createRunRenderer } from "./event-renderer.js";
+export type { SlackRenderTransport } from "./render/transport.js";
+export { decodeInteraction, conversationKeyOf } from "./interaction.js";
+export { renderBlockKit, renderSlackMessage, buildFeedbackBlocks, FEEDBACK_ACTION_ID, } from "./render/block-kit.js";
+export { renderSlackModal } from "./render/modal.js";
+export { SLACK_LIMITS } from "./render/budget.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,MAAM,yBAAyB,CAAC;AACjE,YAAY,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAI5D,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AACxC,OAAO,EACL,mBAAmB,EACnB,aAAa,EACb,aAAa,EACb,kBAAkB,GACnB,MAAM,wBAAwB,CAAC;AAChC,YAAY,EACV,iBAAiB,EACjB,gBAAgB,GACjB,MAAM,wBAAwB,CAAC;AAEhC,YAAY,EACV,eAAe,EACf,YAAY,EACZ,6BAA6B,EAC7B,WAAW,EACX,qBAAqB,EACrB,sBAAsB,EACtB,aAAa,EACb,oBAAoB,EACpB,qBAAqB,EACrB,qBAAqB,EACrB,oBAAoB,GACrB,MAAM,YAAY,CAAC;AACpB,OAAO,EACL,gCAAgC,EAChC,QAAQ,EACR,4BAA4B,GAC7B,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,YAAY,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAE/D,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AACnE,YAAY,EAAE,0BAA0B,EAAE,MAAM,6BAA6B,CAAC;AAE9E,OAAO,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AACzD,YAAY,EACV,yBAAyB,EACzB,qBAAqB,EACrB,UAAU,GACX,MAAM,oBAAoB,CAAC;AAE5B,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AACjD,YAAY,EAAE,qBAAqB,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAE7E,OAAO,EACL,qBAAqB,EACrB,iBAAiB,EACjB,mBAAmB,GACpB,MAAM,2BAA2B,CAAC;AACnC,YAAY,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAC;AAErE,OAAO,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAE3D,OAAO,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAC1D,YAAY,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAEvE,OAAO,EACL,mBAAmB,EACnB,sBAAsB,EACtB,6BAA6B,EAC7B,mBAAmB,GACpB,MAAM,uBAAuB,CAAC;AAE/B,OAAO,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AAEjE,OAAO,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAC;AAC5D,YAAY,EACV,YAAY,EACZ,gBAAgB,EAChB,kBAAkB,GACnB,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EAAE,mBAAmB,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAE7E,OAAO,EAAE,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AACnD,YAAY,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AAExD,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AACxD,YAAY,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAC;AAElE,OAAO,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAExE,OAAO,EACL,cAAc,EACd,kBAAkB,EAClB,mBAAmB,EACnB,kBAAkB,GACnB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC"}

package/dist/index.js

@@ -0,0 +1,23 @@
+export { SlackConversationStore } from "./conversation-store.js";
+// Pure Slack codec (render + normalize) shared with the managed/Connector-Outbox
+// and webhook-ingress paths.
+export { slackCodec } from "./codec.js";
+export { normalizeSlackEvent, stripMentions, deriveEventId, isPlainUserMessage, } from "./ingress-normalize.js";
+export { DEFAULT_SLACK_RESPOND_TO_OPTIONS, DM_SCOPE, resolveSlackRespondToOptions, } from "./types.js";
+export { MessageStream } from "./message-stream.js";
+export { ChunkedMessageStream } from "./chunked-message-stream.js";
+export { NativeMessageStream } from "./native-stream.js";
+export { attachAssistant } from "./assistant.js";
+export { autoCloseOpenMarkdown, detectOpenContext, renderContextOpener, } from "./auto-close-streaming.js";
+export { markdownToMrkdwn } from "./markdown-to-mrkdwn.js";
+export { attachSlackListener } from "./slack-listener.js";
+export { slackTaggingContext, slackFormattingContext, slackConversationModelContext, defaultSlackContext, } from "./built-in-context.js";
+export { SanitizingHttpAgent } from "./sanitizing-http-agent.js";
+export { buildFileContentParts } from "./download-files.js";
+export { lookupSlackUserTool, defaultSlackTools } from "./built-in-tools.js";
+export { slack, SlackAdapter } from "./adapter.js";
+export { createRunRenderer } from "./event-renderer.js";
+export { decodeInteraction, conversationKeyOf } from "./interaction.js";
+export { renderBlockKit, renderSlackMessage, buildFeedbackBlocks, FEEDBACK_ACTION_ID, } from "./render/block-kit.js";
+export { renderSlackModal } from "./render/modal.js";
+export { SLACK_LIMITS } from "./render/budget.js";

package/dist/ingress-normalize.d.ts

@@ -0,0 +1,75 @@
+/** Strip `<@U…>` / `<@U…|handle>` mention tokens and collapse whitespace. */
+export declare const stripMentions: (text: string) => string;
+/**
+ * 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 declare function deriveEventId(body: unknown, event: {
+    client_msg_id?: string;
+    ts?: string;
+    channel?: string;
+}, channel: string): string | undefined;
+/** Minimal shape of a plain Slack message we care about, after filtering. */
+export interface PlainUserMessage {
+    channel: string;
+    text: string;
+    user?: string;
+    thread_ts?: string;
+    channel_type?: string;
+    files?: unknown[];
+    /** Slack's client-generated message id; a per-delivery dedup fallback. */
+    client_msg_id?: string;
+    /** Message ts; last-resort dedup key as `${channel}:${ts}`. */
+    ts?: string;
+}
+/**
+ * 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 declare function isPlainUserMessage(message: unknown, botUserId: string | undefined): message is PlainUserMessage;
+/** Platform-neutral ingress event the closed Intelligence side maps to its envelope. */
+export type SlackNeutralEvent = {
+    kind: "turn";
+    /** Which Slack trigger produced this turn. */
+    source: "app_mention" | "direct_message" | "thread_reply";
+    channel: string;
+    /** Thread anchor: present for mentions and thread replies. */
+    threadTs?: string;
+    /** Inbound message ts (lets a renderer anchor a "thinking…" status on DMs). */
+    ts?: string;
+    userText: string;
+    senderUserId?: string;
+    eventId?: string;
+    hasFiles: boolean;
+} | {
+    kind: "command";
+    command: string;
+    text: string;
+    channel: string;
+    senderUserId?: string;
+    triggerId?: string;
+    eventId?: string;
+};
+interface RawSlackEventBody {
+    command?: string;
+    text?: string;
+    channel_id?: string;
+    user_id?: string;
+    trigger_id?: string;
+    event_id?: string;
+    event?: Record<string, unknown>;
+}
+/**
+ * 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 declare function normalizeSlackEvent(body: RawSlackEventBody, botUserId?: string): SlackNeutralEvent | undefined;
+export {};
+//# sourceMappingURL=ingress-normalize.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ingress-normalize.d.ts","sourceRoot":"","sources":["../src/ingress-normalize.ts"],"names":[],"mappings":"AAeA,6EAA6E;AAC7E,eAAO,MAAM,aAAa,GAAI,MAAM,MAAM,KAAG,MACa,CAAC;AAE3D;;;;;;GAMG;AACH,wBAAgB,aAAa,CAC3B,IAAI,EAAE,OAAO,EACb,KAAK,EAAE;IAAE,aAAa,CAAC,EAAE,MAAM,CAAC;IAAC,EAAE,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAE,EAChE,OAAO,EAAE,MAAM,GACd,MAAM,GAAG,SAAS,CAMpB;AAED,6EAA6E;AAC7E,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,KAAK,CAAC,EAAE,OAAO,EAAE,CAAC;IAClB,0EAA0E;IAC1E,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,+DAA+D;IAC/D,EAAE,CAAC,EAAE,MAAM,CAAC;CACb;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,OAAO,EAChB,SAAS,EAAE,MAAM,GAAG,SAAS,GAC5B,OAAO,IAAI,gBAAgB,CAe7B;AAED,wFAAwF;AACxF,MAAM,MAAM,iBAAiB,GACzB;IACE,IAAI,EAAE,MAAM,CAAC;IACb,8CAA8C;IAC9C,MAAM,EAAE,aAAa,GAAG,gBAAgB,GAAG,cAAc,CAAC;IAC1D,OAAO,EAAE,MAAM,CAAC;IAChB,8DAA8D;IAC9D,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,+EAA+E;IAC/E,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,OAAO,CAAC;CACnB,GACD;IACE,IAAI,EAAE,SAAS,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAEN,UAAU,iBAAiB;IACzB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACjC;AAMD;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,iBAAiB,EACvB,SAAS,CAAC,EAAE,MAAM,GACjB,iBAAiB,GAAG,SAAS,CAyF/B"}