@cursor/july 0.1.1

package/dist/channels/slack/cursor-account.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cursor-account.d.ts","sourceRoot":"","sources":["../../../src/channels/slack/cursor-account.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAEjE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAE1D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AACzC,OAAO,KAAK,EACV,iBAAiB,EACjB,mBAAmB,EACnB,gBAAgB,EAEhB,mBAAmB,EACpB,MAAM,YAAY,CAAC;AAEpB;;;;GAIG;AACH,MAAM,WAAW,wBAAyB,SAAQ,iBAAiB;IACjE,IAAI,CAAC,IAAI,EAAE,iBAAiB,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC;CAC7C;AAED,wBAAgB,8BAA8B,IAAI,wBAAwB,CAezE;AAED;;;GAGG;AACH,MAAM,WAAW,mBAAmB;IAClC,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB;;OAEG;IACH,SAAS,EAAE,MAAM,GAAG,QAAQ,CAAC;IAC7B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,sEAAsE;AACtE,MAAM,WAAW,yBAAyB;IACxC,OAAO,EAAE,mBAAmB,CAAC;IAC7B,0EAA0E;IAC1E,WAAW,EAAE,gBAAgB,CAAC;IAC9B,SAAS,EAAE,wBAAwB,CAAC;IACpC,QAAQ,EAAE,aAAa,CAAC;IACxB,YAAY,EAAE,mBAAmB,CAAC;IAClC,eAAe,EAAE,mBAAmB,CAAC;IACrC,MAAM,EAAE,MAAM,QAAQ,CAAC;CACxB;AAID,wBAAgB,iCAAiC,CAC/C,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,yBAAyB,GACjC,IAAI,CAEN;AAED;;;GAGG;AACH,wBAAgB,4BAA4B,CAC1C,UAAU,EAAE,MAAM,GACjB,yBAAyB,GAAG,SAAS,CAEvC;AAED;;;GAGG;AACH,wBAAsB,2BAA2B,CAAC,IAAI,EAAE;IACtD,OAAO,EAAE,yBAAyB,CAAC;IACnC,QAAQ,EAAE,mBAAmB,CAAC;IAC9B,IAAI,EAAE,aAAa,CAAC;IACpB,IAAI,EAAE,WAAW,CAAC;CACnB,GAAG,OAAO,CAAC,IAAI,CAAC,CAiDhB"}

package/dist/channels/slack/cursor-account.js

@@ -0,0 +1,88 @@
+/**
+ * Cursor-account mode for the Slack channel pack: instead of a dedicated
+ * Slack app (Socket Mode + `xoxb`/`xapp` tokens), the channel rides the
+ * signed-in Cursor account's Slack connection. Inbound events are relayed
+ * by the serve host from `/v0/slack-events` (see
+ * `internal/cursor-slack-relay.ts`); outbound Web API calls run through a
+ * {@link SlackApiTransport} bound to the backend proxy.
+ *
+ * This file is the seam between the channel definition (authored at
+ * `defineChannel` time) and the serve-time relay: `slackChannel()` registers
+ * a runtime ref here, and the server discovers it, binds the transport, and
+ * dispatches relayed envelopes through the pack's normal inbound path.
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { dispatchInboundMessage } from "./dispatch.js";
+import { slackTextToMarkdown } from "./inbound.js";
+export function createPendingSlackApiTransport() {
+    let bound;
+    return {
+        kind: "api-transport",
+        label: "cursor-account",
+        bind(impl) {
+            bound = impl;
+        },
+        call(method, args) {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (bound === undefined) {
+                    return { ok: false, error: "cursor_slack_relay_not_started" };
+                }
+                return bound(method, args);
+            });
+        },
+    };
+}
+const runtimeByDefinition = new WeakMap();
+export function registerSlackCursorAccountRuntime(definition, runtime) {
+    runtimeByDefinition.set(definition, runtime);
+}
+/**
+ * Recover the cursor-account runtime for a channel definition, if it was
+ * created via `slackChannel({ cursorAccount: true })`.
+ */
+export function getSlackCursorAccountRuntime(definition) {
+    return runtimeByDefinition.get(definition);
+}
+/**
+ * Dispatch one relayed envelope through the pack's normal inbound path
+ * (same handlers, session continuation, and reply delivery as Socket Mode).
+ */
+export function dispatchCursorSlackEnvelope(args) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { runtime, envelope } = args;
+        const log = runtime.getLog();
+        if (envelope.eventId !== undefined &&
+            envelope.eventId.length > 0 &&
+            !runtime.eventIds.tryHandle(envelope.eventId)) {
+            log.debug("cursor-account inbound dedupe drop", {
+                event_id: envelope.eventId,
+            });
+            return;
+        }
+        const message = Object.assign({ text: envelope.text, markdown: slackTextToMarkdown(envelope.text), ts: envelope.messageTs, threadTs: envelope.threadTs, channelId: envelope.channelId, teamId: envelope.slackTeamId }, (envelope.slackUserId === undefined
+            ? {}
+            : {
+                author: { userId: envelope.slackUserId, isBot: false },
+            }));
+        // DMs to @Cursor route as direct messages; everything else (explicit
+        // `@Cursor <agent> …` mentions and claimed-thread replies) dispatches on
+        // the mention handler — a claimed-thread reply is addressed to the agent
+        // by construction. Mentions/DM disable toggles are rejected at
+        // `slackChannel({ cursorAccount: true })` construction so the backend
+        // never consumes events the host would drop.
+        const isDm = envelope.channelType === "im" || envelope.channelId.startsWith("D");
+        const kind = isDm ? "direct_message" : "app_mention";
+        const handler = isDm ? runtime.onDirectMessage : runtime.onAppMention;
+        yield dispatchInboundMessage(Object.assign({ kind,
+            message,
+            handler, send: args.send, credentials: runtime.credentials, host: args.host, log }, (envelope.eventId === undefined ? {} : { eventId: envelope.eventId })));
+    });
+}

package/dist/channels/slack/defaults.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Default inbound handlers and stream-event sinks for the Slack channel.
+ */
+import type { ChannelEventHandlers } from "../../types.js";
+import { type SlackLog } from "./log.js";
+import type { SlackChannelState, SlackCredentials, SlackMessageHandler, SlackSuggestedPrompt } from "./types.js";
+export declare const defaultOnAppMention: SlackMessageHandler;
+export declare const defaultOnDirectMessage: SlackMessageHandler;
+/**
+ * Default watched-channel-post handler: same thread-scoped principal as
+ * mentions (so a later @mention continues the session), tagged with an
+ * `engagement: "channel_post"` attribute for auth policies.
+ */
+export declare const defaultOnChannelPost: SlackMessageHandler;
+export interface BuildDefaultEventsOptions {
+    credentials?: SlackCredentials;
+    streaming?: boolean;
+    thinkingSteps?: boolean;
+    suggestedPrompts?: SlackSuggestedPrompt[];
+    suggestedPromptsTitle?: string;
+    /** Resolved per-call so channel onStart can rebind the server logger. */
+    getLog?: () => SlackLog;
+}
+/**
+ * Build default stream-event handlers (typing, streaming, replies).
+ * Streaming / thinking default to ON.
+ *
+ * Tool-approval cards are a separate primitive — compose with
+ * `buildToolApprovalEvents` or set `toolApprovals: true` on `slackChannel`.
+ */
+export declare function buildDefaultEvents(options?: BuildDefaultEventsOptions): ChannelEventHandlers<SlackChannelState>;
+//# sourceMappingURL=defaults.d.ts.map

package/dist/channels/slack/defaults.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"defaults.d.ts","sourceRoot":"","sources":["../../../src/channels/slack/defaults.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAe3D,OAAO,EAAmB,KAAK,QAAQ,EAAE,MAAM,UAAU,CAAC;AAE1D,OAAO,KAAK,EACV,iBAAiB,EACjB,gBAAgB,EAChB,mBAAmB,EACnB,oBAAoB,EACrB,MAAM,YAAY,CAAC;AAQpB,eAAO,MAAM,mBAAmB,EAAE,mBAAsC,CAAC;AACzE,eAAO,MAAM,sBAAsB,EAAE,mBAAsC,CAAC;AAE5E;;;;GAIG;AACH,eAAO,MAAM,oBAAoB,EAAE,mBAOlC,CAAC;AAEF,MAAM,WAAW,yBAAyB;IACxC,WAAW,CAAC,EAAE,gBAAgB,CAAC;IAC/B,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,gBAAgB,CAAC,EAAE,oBAAoB,EAAE,CAAC;IAC1C,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAC/B,yEAAyE;IACzE,MAAM,CAAC,EAAE,MAAM,QAAQ,CAAC;CACzB;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAChC,OAAO,GAAE,yBAA8B,GACtC,oBAAoB,CAAC,iBAAiB,CAAC,CA2XzC"}

package/dist/channels/slack/defaults.js

@@ -0,0 +1,380 @@
+/**
+ * Default inbound handlers and stream-event sinks for the Slack channel.
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { appendChatStream, postMessage, setThreadStatus, truncateTypingStatus, } from "./api.js";
+import { firstNonEmptyLine, maybeSetSuggestedPrompts } from "./assistant.js";
+import { defaultSlackAuth } from "./auth.js";
+import { SLACK_DEFAULT_LOADING_MESSAGES, SLACK_TYPING_MIN_GROWTH, SLACK_TYPING_MIN_INTERVAL_MS, } from "./constants.js";
+import { createStreamDeliveryStrategy } from "./live-delivery.js";
+import { defaultSlackLog } from "./log.js";
+import { buildTaskChunkForResult, buildTaskChunksForCalls } from "./stream.js";
+const defaultOnInbound = (ctx, message) => __awaiter(void 0, void 0, void 0, function* () {
+    yield ctx.thread.startTyping("Thinking…");
+    const auth = defaultSlackAuth(message, ctx);
+    return auth === null ? null : { auth };
+});
+export const defaultOnAppMention = defaultOnInbound;
+export const defaultOnDirectMessage = defaultOnInbound;
+/**
+ * Default watched-channel-post handler: same thread-scoped principal as
+ * mentions (so a later @mention continues the session), tagged with an
+ * `engagement: "channel_post"` attribute for auth policies.
+ */
+export const defaultOnChannelPost = (ctx, message) => __awaiter(void 0, void 0, void 0, function* () {
+    yield ctx.thread.startTyping("Thinking…");
+    const auth = defaultSlackAuth(message, ctx, { engagement: "channel_post" });
+    return auth === null ? null : { auth };
+});
+/**
+ * Build default stream-event handlers (typing, streaming, replies).
+ * Streaming / thinking default to ON.
+ *
+ * Tool-approval cards are a separate primitive — compose with
+ * `buildToolApprovalEvents` or set `toolApprovals: true` on `slackChannel`.
+ */
+export function buildDefaultEvents(options = {}) {
+    var _a, _b;
+    const credentials = options.credentials;
+    const streaming = options.streaming !== false;
+    const thinkingSteps = options.thinkingSteps !== false;
+    const suggestedPrompts = (_a = options.suggestedPrompts) !== null && _a !== void 0 ? _a : [];
+    const suggestedPromptsTitle = options.suggestedPromptsTitle;
+    const botToken = credentials === null || credentials === void 0 ? void 0 : credentials.botToken;
+    const getLog = (_b = options.getLog) !== null && _b !== void 0 ? _b : (() => defaultSlackLog);
+    const strategy = createStreamDeliveryStrategy({ botToken, getLog });
+    return {
+        "turn.started"(event, channel) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const log = getLog();
+                channel.state.pendingToolCallMessage = null;
+                channel.state.lastReasoningTypingAtMs = null;
+                channel.state.lastReasoningTypingStatus = null;
+                channel.state.streamTs = null;
+                channel.state.streamChannelId = null;
+                channel.state.lastPostedText = null;
+                channel.state.approvalMessageByCallId = {};
+                const state = channel.state;
+                if (state.channelId === null || state.threadTs === null) {
+                    return;
+                }
+                log.info("turn.started", {
+                    session: event.sessionId,
+                    turn: event.turnId,
+                    channel: state.channelId,
+                    thread_ts: state.threadTs,
+                });
+                yield setThreadStatus({
+                    botToken,
+                    channelId: state.channelId,
+                    threadTs: state.threadTs,
+                    status: "Working…",
+                    loadingMessages: [...SLACK_DEFAULT_LOADING_MESSAGES],
+                });
+                // Retry streaming each turn unless a prior call proved the feature
+                // unsupported for this workspace/app. Thinking stays on setStatus
+                // (Cursor-account proxy pins agent username/icon on that method).
+                if (!streaming || state.streamingUnavailable === true) {
+                    return;
+                }
+                yield strategy.start({
+                    channel,
+                    channelId: state.channelId,
+                    threadTs: state.threadTs,
+                    sessionId: event.sessionId,
+                });
+            });
+        },
+        "message.appended"(event, channel) {
+            return __awaiter(this, void 0, void 0, function* () {
+                var _a;
+                if (!streaming || channel.state.streamingUnavailable === true) {
+                    return;
+                }
+                const streamTs = channel.state.streamTs;
+                const channelId = (_a = channel.state.streamChannelId) !== null && _a !== void 0 ? _a : channel.state.channelId;
+                if (streamTs === null ||
+                    streamTs === "" ||
+                    channelId === null ||
+                    channelId === "") {
+                    return;
+                }
+                yield strategy.append({
+                    channel,
+                    channelId,
+                    streamTs,
+                    text: event.data.text,
+                    sessionId: event.sessionId,
+                });
+            });
+        },
+        "reasoning.appended"(event, channel) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const line = firstNonEmptyLine(event.data.text);
+                if (line === undefined) {
+                    return;
+                }
+                const status = truncateTypingStatus(line);
+                const previous = channel.state.lastReasoningTypingStatus;
+                const grew = previous !== null &&
+                    status.startsWith(previous) &&
+                    status.length >= previous.length + SLACK_TYPING_MIN_GROWTH;
+                const now = Date.now();
+                const lastAt = channel.state.lastReasoningTypingAtMs;
+                if (!grew &&
+                    lastAt !== null &&
+                    now - lastAt >= 0 &&
+                    now - lastAt < SLACK_TYPING_MIN_INTERVAL_MS) {
+                    return;
+                }
+                if (channel.state.channelId === null || channel.state.threadTs === null) {
+                    return;
+                }
+                yield setThreadStatus({
+                    botToken,
+                    channelId: channel.state.channelId,
+                    threadTs: channel.state.threadTs,
+                    status,
+                    loadingMessages: [status, ...SLACK_DEFAULT_LOADING_MESSAGES],
+                });
+                channel.state.lastReasoningTypingAtMs = now;
+                channel.state.lastReasoningTypingStatus = status;
+            });
+        },
+        "actions.requested"(event, channel) {
+            return __awaiter(this, void 0, void 0, function* () {
+                var _a;
+                const pending = channel.state.pendingToolCallMessage;
+                channel.state.pendingToolCallMessage = null;
+                const names = event.data.calls.map((call) => call.toolName);
+                const statusText = pending !== null
+                    ? truncateTypingStatus(pending)
+                    : truncateTypingStatus(`Running ${names.join(", ")}…`);
+                if (strategy.inlineToolSteps &&
+                    thinkingSteps &&
+                    streaming &&
+                    channel.state.streamingUnavailable !== true &&
+                    channel.state.streamTs !== null &&
+                    channel.state.streamTs !== "") {
+                    const channelId = (_a = channel.state.streamChannelId) !== null && _a !== void 0 ? _a : channel.state.channelId;
+                    if (channelId !== null && channelId !== "") {
+                        const chunks = buildTaskChunksForCalls(event.data.calls, "in_progress");
+                        const result = yield appendChatStream({
+                            botToken,
+                            channel: channelId,
+                            ts: channel.state.streamTs,
+                            chunks,
+                        });
+                        if (result.ok) {
+                            if (channel.state.channelId !== null &&
+                                channel.state.threadTs !== null) {
+                                yield setThreadStatus({
+                                    botToken,
+                                    channelId: channel.state.channelId,
+                                    threadTs: channel.state.threadTs,
+                                    status: statusText,
+                                });
+                            }
+                            return;
+                        }
+                    }
+                }
+                if (channel.state.channelId !== null && channel.state.threadTs !== null) {
+                    yield setThreadStatus({
+                        botToken,
+                        channelId: channel.state.channelId,
+                        threadTs: channel.state.threadTs,
+                        status: statusText,
+                    });
+                }
+            });
+        },
+        "action.result"(event, channel) {
+            return __awaiter(this, void 0, void 0, function* () {
+                var _a;
+                if (!strategy.inlineToolSteps ||
+                    !thinkingSteps ||
+                    !streaming ||
+                    channel.state.streamingUnavailable === true ||
+                    channel.state.streamTs === null ||
+                    channel.state.streamTs === "") {
+                    return;
+                }
+                const channelId = (_a = channel.state.streamChannelId) !== null && _a !== void 0 ? _a : channel.state.channelId;
+                if (channelId === null || channelId === "") {
+                    return;
+                }
+                const chunk = buildTaskChunkForResult({
+                    callId: event.data.callId,
+                    toolName: event.data.toolName,
+                    isError: event.data.isError,
+                });
+                yield appendChatStream({
+                    botToken,
+                    channel: channelId,
+                    ts: channel.state.streamTs,
+                    chunks: [chunk],
+                });
+            });
+        },
+        "message.completed"(event, channel) {
+            return __awaiter(this, void 0, void 0, function* () {
+                var _a, _b, _c;
+                const log = getLog();
+                if (event.data.finishReason === "tool_call") {
+                    channel.state.pendingToolCallMessage = (_a = firstNonEmptyLine(event.data.text)) !== null && _a !== void 0 ? _a : null;
+                    return;
+                }
+                channel.state.pendingToolCallMessage = null;
+                const state = channel.state;
+                if (state.channelId === null || state.threadTs === null) {
+                    return;
+                }
+                const clearStatus = () => __awaiter(this, void 0, void 0, function* () {
+                    yield setThreadStatus({
+                        botToken,
+                        channelId: state.channelId,
+                        threadTs: state.threadTs,
+                        status: "",
+                    });
+                });
+                // Empty final text: still close any open stream / clear the skeleton
+                // and clear typing.
+                if (event.data.text === "") {
+                    if (state.streamTs !== null && state.streamTs !== "") {
+                        yield strategy.finalizeEmpty({
+                            channel,
+                            channelId: (_b = state.streamChannelId) !== null && _b !== void 0 ? _b : state.channelId,
+                            streamTs: state.streamTs,
+                        });
+                        channel.state.streamTs = null;
+                    }
+                    yield clearStatus();
+                    return;
+                }
+                const canStream = streaming &&
+                    state.streamingUnavailable !== true &&
+                    state.streamTs !== null &&
+                    state.streamTs !== "";
+                if (canStream && state.streamTs !== null) {
+                    const { delivered } = yield strategy.finalize({
+                        channel,
+                        channelId: (_c = state.streamChannelId) !== null && _c !== void 0 ? _c : state.channelId,
+                        streamTs: state.streamTs,
+                        text: event.data.text,
+                        sessionId: event.sessionId,
+                    });
+                    if (delivered) {
+                        yield clearStatus();
+                        return;
+                    }
+                }
+                try {
+                    const posted = yield postMessage({
+                        botToken,
+                        channel: state.channelId,
+                        text: event.data.text,
+                        threadTs: state.threadTs,
+                    });
+                    channel.state.lastPostedText = event.data.text;
+                    log.info("reply delivered via postMessage", {
+                        channel: state.channelId,
+                        thread_ts: state.threadTs,
+                        message_ts: posted.ts,
+                        session: event.sessionId,
+                        chars: event.data.text.length,
+                    });
+                }
+                catch (error) {
+                    log.error(`postMessage failed: ${error instanceof Error ? error.message : String(error)}`, {
+                        channel: state.channelId,
+                        thread_ts: state.threadTs,
+                        session: event.sessionId,
+                    });
+                }
+                yield clearStatus();
+            });
+        },
+        "turn.completed"(event, channel) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const log = getLog();
+                log.info("turn.completed", {
+                    session: event.sessionId,
+                    turn: event.turnId,
+                    channel: channel.state.channelId,
+                    thread_ts: channel.state.threadTs,
+                });
+                yield strategy.cleanupOrphan({ channel });
+                if (suggestedPrompts.length === 0 ||
+                    channel.state.channelId === null ||
+                    channel.state.threadTs === null) {
+                    return;
+                }
+                yield maybeSetSuggestedPrompts(Object.assign(Object.assign({ botToken, channelId: channel.state.channelId, threadTs: channel.state.threadTs, prompts: suggestedPrompts }, (suggestedPromptsTitle === undefined
+                    ? {}
+                    : { title: suggestedPromptsTitle })), { log }));
+            });
+        },
+        "turn.failed"(event, channel) {
+            return __awaiter(this, void 0, void 0, function* () {
+                var _a;
+                const log = getLog();
+                const state = channel.state;
+                log.error("turn.failed", {
+                    session: event.sessionId,
+                    turn: event.turnId,
+                    error: event.data.message,
+                    channel: state.channelId,
+                    thread_ts: state.threadTs,
+                });
+                if (state.channelId === null || state.threadTs === null) {
+                    return;
+                }
+                // Do not echo engine/tool error text into Slack — it can leak
+                // paths, tokens, or other sensitive detail to workspace members.
+                const errorText = "I hit an error while handling your request. Please try again or rephrase.";
+                let delivered = false;
+                if (state.streamTs !== null && state.streamTs !== "") {
+                    ({ delivered } = yield strategy.fail({
+                        channel,
+                        channelId: (_a = state.streamChannelId) !== null && _a !== void 0 ? _a : state.channelId,
+                        streamTs: state.streamTs,
+                        errorText,
+                        sessionId: event.sessionId,
+                    }));
+                }
+                if (!delivered) {
+                    try {
+                        yield postMessage({
+                            botToken,
+                            channel: state.channelId,
+                            text: errorText,
+                            threadTs: state.threadTs,
+                        });
+                    }
+                    catch (error) {
+                        log.error(`turn.failed postMessage failed: ${error instanceof Error ? error.message : String(error)}`, {
+                            channel: state.channelId,
+                            thread_ts: state.threadTs,
+                            session: event.sessionId,
+                        });
+                    }
+                }
+                yield setThreadStatus({
+                    botToken,
+                    channelId: state.channelId,
+                    threadTs: state.threadTs,
+                    status: "",
+                });
+            });
+        },
+    };
+}

package/dist/channels/slack/dispatch.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Shared inbound dispatch for Slack Events API bodies and Socket Mode.
+ */
+import type { HostContext, SendMessageFn } from "../../types.js";
+import type { ChannelPostWatcher } from "./channel-watch.js";
+import type { EventIdDedupe } from "./event-id-dedupe.js";
+import { type SlackLog } from "./log.js";
+import type { SlackChannelState, SlackCredentials, SlackMessage, SlackMessageHandler } from "./types.js";
+/** Blank per-session adapter state. */
+export declare function emptySlackChannelState(patch?: Partial<SlackChannelState>): SlackChannelState;
+export interface SlackInboundDispatchDeps {
+    send: SendMessageFn;
+    waitUntil: (promise: Promise<unknown>) => void;
+    onAppMention: SlackMessageHandler;
+    onDirectMessage: SlackMessageHandler;
+    credentials: SlackCredentials | undefined;
+    eventIds: EventIdDedupe;
+    host: HostContext;
+    log?: SlackLog;
+    /** Dispatch on `app_mention`. Defaults to `true`. */
+    mentionsEnabled?: boolean;
+    /** Dispatch on direct messages. Defaults to `true`. */
+    directMessagesEnabled?: boolean;
+    /** Opt-in channel watch; absent = channel posts are ignored. */
+    channelWatch?: ChannelPostWatcher;
+}
+export declare function dispatchInboundMessage(args: {
+    kind: "app_mention" | "direct_message" | "channel_post";
+    message: SlackMessage;
+    handler: SlackMessageHandler;
+    send: SendMessageFn;
+    credentials: SlackCredentials | undefined;
+    host: HostContext;
+    log?: SlackLog;
+    eventId?: string;
+}): Promise<void>;
+/**
+ * Parse an Events API body (or Socket Mode `events_api` payload) and dispatch
+ * app_mention / DM handlers. Deduplicates by `event_id` when present. Returns
+ * true when a handler was scheduled.
+ */
+export declare function dispatchInboundFromEventBody(body: unknown, deps: SlackInboundDispatchDeps): boolean;
+//# sourceMappingURL=dispatch.d.ts.map

package/dist/channels/slack/dispatch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dispatch.d.ts","sourceRoot":"","sources":["../../../src/channels/slack/dispatch.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,KAAK,EAAE,WAAW,EAAa,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAG5E,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AAC7D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAO1D,OAAO,EAAmB,KAAK,QAAQ,EAAE,MAAM,UAAU,CAAC;AAC1D,OAAO,KAAK,EACV,iBAAiB,EACjB,gBAAgB,EAEhB,YAAY,EACZ,mBAAmB,EACpB,MAAM,YAAY,CAAC;AAKpB,uCAAuC;AACvC,wBAAgB,sBAAsB,CACpC,KAAK,GAAE,OAAO,CAAC,iBAAiB,CAAM,GACrC,iBAAiB,CAgBnB;AAED,MAAM,WAAW,wBAAwB;IACvC,IAAI,EAAE,aAAa,CAAC;IACpB,SAAS,EAAE,CAAC,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC,KAAK,IAAI,CAAC;IAC/C,YAAY,EAAE,mBAAmB,CAAC;IAClC,eAAe,EAAE,mBAAmB,CAAC;IACrC,WAAW,EAAE,gBAAgB,GAAG,SAAS,CAAC;IAC1C,QAAQ,EAAE,aAAa,CAAC;IACxB,IAAI,EAAE,WAAW,CAAC;IAClB,GAAG,CAAC,EAAE,QAAQ,CAAC;IACf,qDAAqD;IACrD,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,uDAAuD;IACvD,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC,gEAAgE;IAChE,YAAY,CAAC,EAAE,kBAAkB,CAAC;CACnC;AAED,wBAAsB,sBAAsB,CAAC,IAAI,EAAE;IACjD,IAAI,EAAE,aAAa,GAAG,gBAAgB,GAAG,cAAc,CAAC;IACxD,OAAO,EAAE,YAAY,CAAC;IACtB,OAAO,EAAE,mBAAmB,CAAC;IAC7B,IAAI,EAAE,aAAa,CAAC;IACpB,WAAW,EAAE,gBAAgB,GAAG,SAAS,CAAC;IAC1C,IAAI,EAAE,WAAW,CAAC;IAClB,GAAG,CAAC,EAAE,QAAQ,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,GAAG,OAAO,CAAC,IAAI,CAAC,CA2IhB;AAED;;;;GAIG;AACH,wBAAgB,4BAA4B,CAC1C,IAAI,EAAE,OAAO,EACb,IAAI,EAAE,wBAAwB,GAC7B,OAAO,CAoET"}