@cursor/bdk 0.2.8 → 0.2.10

package/dist/channels/slack/slack-channel.js

@@ -8,20 +8,13 @@
  *
  * Hosted v2 transport is the control plane's Events API ingest: the CP
  * verifies the managed app's signature, fans out on the declared
- * `slackEventTypes` (`app_mention`, `message`), and delivers the full
- * `event_callback` body through hosted admission — the attached adapter
- * routes it through the same inbound dispatch as Socket Mode. Hosted pods
- * skip Socket Mode entirely, so they never need an app token.
+ * `slackEventTypes` (`app_mention`, `message`, plus `reaction_added` and
+ * `block_actions` when their handlers are set), and delivers the full
+ * `event_callback` body — or, for a Block Kit click, the interactivity
+ * payload — through hosted admission. The attached adapter routes it
+ * through the same inbound and Block Kit dispatch as Socket Mode. Hosted
+ * pods skip Socket Mode entirely, so they never need an app token.
  */
-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 { allowAll, defineChannel } from "../../channels.js";
 import { skipped, withPropagatingBackgroundErrors } from "../../internal/channel-dispatch.js";
 import { continuationSource, normalizeIdentity } from "../../internal/continuation-identity.js";
@@ -36,7 +29,8 @@ import { buildDefaultEvents, createDefaultOnChannelPost, createDefaultOnInbound,
 import { dispatchInboundFromEventBody, dispatchInboundMessage, emptySlackChannelState, slackWakeChannelState, } from "./dispatch.js";
 import { createEventIdDedupe } from "./event-id-dedupe.js";
 import { parseChannelMessageEvent, parseEventBodyBotUserId } from "./inbound.js";
-import { dispatchBlockAction, dispatchInteractiveFromPayload } from "./interactive.js";
+import { decisionFromActionId, decisionFromAuthActionId, parseApprovalActionValue, } from "./approvals.js";
+import { dispatchBlockAction, dispatchInteractiveFromPayload, parseSlackBlockAction, } from "./interactive.js";
 import { createSlackLogger } from "./log.js";
 import { DEFAULT_ACK, resolveSlackReply } from "./reply-options.js";
 import { startSlackSocketMode, } from "./socket-mode.js";
@@ -55,14 +49,13 @@ export function getSlackChannelOptions(definition) {
  * {@link HostContext.slack.getClient}.
  */
 export function resolveDedicatedSlackHostBinding(channels) {
-    var _a;
     for (const channel of channels) {
         const options = slackChannelOptionsByDefinition.get(channel.definition);
         if (options === undefined) {
             continue;
         }
         return {
-            credentials: (_a = options.credentials) !== null && _a !== void 0 ? _a : credentialsFromEnv(options.envPrefix),
+            credentials: options.credentials ?? credentialsFromEnv(options.envPrefix),
             envPrefix: options.envPrefix,
         };
     }
@@ -70,10 +63,10 @@ export function resolveDedicatedSlackHostBinding(channels) {
 }
 function authOnlyInbound(policy, engagement) {
     const respondTo = resolveSlackRespondTo(policy);
-    return (ctx, message) => __awaiter(this, void 0, void 0, function* () {
+    return async (ctx, message) => {
         const auth = defaultSlackAuth(message, ctx, { engagement, respondTo });
         return auth === null ? null : { auth };
-    });
+    };
 }
 /**
  * Create a Slack channel. Author as `agent/channels/slack.ts` default export.
@@ -83,12 +76,11 @@ function authOnlyInbound(policy, engagement) {
  * on Slack setup.
  */
 export function slackChannel(authored = {}) {
-    var _a, _b, _c, _d, _e, _f, _g;
-    const options = Object.assign({}, authored);
+    const options = { ...authored };
     if (options.continuation !== undefined) {
         options.continuation = normalizeIdentity(options.continuation, "slack");
     }
-    const credentials = (_a = options.credentials) !== null && _a !== void 0 ? _a : credentialsFromEnv(options.envPrefix);
+    const credentials = options.credentials ?? credentialsFromEnv(options.envPrefix);
     const envKeys = slackEnvKeys(options.envPrefix);
     const reply = resolveSlackReply(options);
     const loadingMessages = reply.status.idle;
@@ -98,17 +90,18 @@ export function slackChannel(authored = {}) {
     const defaultInbound = silent
         ? authOnlyInbound(policy)
         : createDefaultOnInbound(loadingMessages, policy);
-    const onAppMention = (_b = options.onAppMention) !== null && _b !== void 0 ? _b : defaultInbound;
-    const onDirectMessage = (_c = options.onDirectMessage) !== null && _c !== void 0 ? _c : defaultInbound;
+    const onAppMention = options.onAppMention ?? defaultInbound;
+    const onDirectMessage = options.onDirectMessage ?? defaultInbound;
     const onReactionAdded = options.onReactionAdded;
-    const onChannelPost = (_d = options.onChannelPost) !== null && _d !== void 0 ? _d : (silent
-        ? authOnlyInbound(policy, "channel_post")
-        : createDefaultOnChannelPost(loadingMessages, policy));
-    const engagement = (_e = options.engagement) !== null && _e !== void 0 ? _e : {};
+    const onChannelPost = options.onChannelPost ??
+        (silent
+            ? authOnlyInbound(policy, "channel_post")
+            : createDefaultOnChannelPost(loadingMessages, policy));
+    const engagement = options.engagement ?? {};
     const mentionsEnabled = engagement.mentions !== false;
     const directMessagesEnabled = engagement.directMessages !== false;
     const evalCommandsEnabled = options.evalCommands !== false;
-    const followUpStatus = (_f = options.followUpStatus) !== null && _f !== void 0 ? _f : !silent;
+    const followUpStatus = options.followUpStatus ?? !silent;
     const channelPosts = engagement.channelPosts;
     if (channelPosts !== undefined) {
         const allowError = validateChannelPostsAllow(channelPosts.allow);
@@ -124,11 +117,15 @@ export function slackChannel(authored = {}) {
         normalizeBotMentionAllowlist(botMentions.allowFrom);
     }
     const eventIds = createEventIdDedupe();
-    // Hosted v2 event capability, matching what the engagement flags can
-    // dispatch: mentions ride `app_mention`; DMs and watched channel posts
-    // both arrive as `message`. Membership of `slack.thread/v2` admits
-    // exactly these two, so `reaction_added` (hosted follow-up only inside
-    // an existing thread) is deliberately not declared.
+    const toolApprovals = options.toolApprovals === true;
+    const interactivity = options.interactivity === true;
+    const onBlockAction = options.onBlockAction;
+    const routeInteractive = toolApprovals || interactivity || onBlockAction !== undefined;
+    // Hosted v2 event capability, matching what the channel can dispatch:
+    // mentions ride `app_mention`; DMs and watched channel posts both arrive
+    // as `message`; reactions and Block Kit clicks only with their handlers.
+    // Tool-approval clicks are not declared: a parked approval lives in the
+    // executing fork, which hosted admission cannot reach.
     const slackEventTypes = [];
     if (mentionsEnabled) {
         slackEventTypes.push("app_mention");
@@ -136,10 +133,12 @@ export function slackChannel(authored = {}) {
     if (directMessagesEnabled || channelPosts !== undefined) {
         slackEventTypes.push("message");
     }
-    const toolApprovals = options.toolApprovals === true;
-    const interactivity = options.interactivity === true;
-    const onBlockAction = options.onBlockAction;
-    const routeInteractive = toolApprovals || interactivity || onBlockAction !== undefined;
+    if (onReactionAdded !== undefined) {
+        slackEventTypes.push("reaction_added");
+    }
+    if (onBlockAction !== undefined) {
+        slackEventTypes.push("block_actions");
+    }
     const runtime = {
         log: createSlackLogger(options.logger),
     };
@@ -171,137 +170,228 @@ export function slackChannel(authored = {}) {
     // verified envelope.
     let hostedAllowlist;
     let hostedAllowlistReady;
-    function resolveHostedAllowlistNames(allowlist) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const names = allowlist.unresolvedNames();
-            if (names.length === 0) {
-                return;
-            }
-            try {
-                const botToken = yield tryResolveBotToken(credentials);
-                if (botToken === undefined) {
-                    getLog().error("channel watch setup degraded", {
-                        error: "no bot token; #name entries stay unresolved",
-                    });
-                    return;
-                }
-                const { WebClient } = yield import("@slack/web-api");
-                allowlist.applyResolvedNames(yield resolveChannelNames(new WebClient(botToken), names, getLog()));
-            }
-            catch (error) {
+    async function resolveHostedAllowlistNames(allowlist) {
+        const names = allowlist.unresolvedNames();
+        if (names.length === 0) {
+            return;
+        }
+        try {
+            const botToken = await tryResolveBotToken(credentials);
+            if (botToken === undefined) {
                 getLog().error("channel watch setup degraded", {
-                    error: error instanceof Error ? error.message : String(error),
+                    error: "no bot token; #name entries stay unresolved",
                 });
+                return;
             }
-        });
+            const { WebClient } = await import("@slack/web-api");
+            allowlist.applyResolvedNames(await resolveChannelNames(new WebClient(botToken), names, getLog()));
+        }
+        catch (error) {
+            getLog().error("channel watch setup degraded", {
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
     }
     /**
      * Only a channel post needs the watcher, so mentions and DMs never wait on
      * it, and a channel already matched by id never waits on `#name` resolution.
      */
-    function hostedChannelWatch(payload, args, platformHandoff) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (channelPosts === undefined) {
-                return undefined;
-            }
-            const channelEvent = parseChannelMessageEvent(payload, {
-                includeBotAuthored: true,
-            });
-            if (channelEvent === null || channelEvent.kind === "deleted") {
-                return undefined;
-            }
-            hostedAllowlist !== null && hostedAllowlist !== void 0 ? hostedAllowlist : (hostedAllowlist = new SlackChannelAllowlist(channelPosts.allow));
-            if (!hostedAllowlist.matches(channelEvent.message.channelId) &&
-                hostedAllowlist.unresolvedNames().length > 0) {
-                hostedAllowlistReady !== null && hostedAllowlistReady !== void 0 ? hostedAllowlistReady : (hostedAllowlistReady = resolveHostedAllowlistNames(hostedAllowlist));
-                yield hostedAllowlistReady;
-            }
-            const botUserId = parseEventBodyBotUserId(payload);
-            return createChannelPostWatcher({
-                // Admission answers before a debounce timer could fire; edits arrive
-                // as their own deliveries and the edge drops them.
-                options: Object.assign(Object.assign({}, channelPosts), { debounceMs: 0 }),
-                allowlist: hostedAllowlist,
-                getBotUserId: () => botUserId,
-                log: getLog(),
-                dispatch: (message, eventId) => {
-                    args.waitUntil(dispatchInboundMessage(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({ kind: "channel_post", message, handler: onChannelPost, propagateHandlerErrors: true, send: args.send, credentials, host: args.host, artifacts: args.artifacts, log: getLog(), evalCommandsEnabled,
-                        followUpStatus, ack: reply.ack, blockExternals, continuation: options.continuation }, (args.hasContinuationSession === undefined
+    async function hostedChannelWatch(payload, args, platformHandoff) {
+        if (channelPosts === undefined) {
+            return undefined;
+        }
+        const channelEvent = parseChannelMessageEvent(payload, {
+            includeBotAuthored: true,
+        });
+        if (channelEvent === null || channelEvent.kind === "deleted") {
+            return undefined;
+        }
+        hostedAllowlist ??= new SlackChannelAllowlist(channelPosts.allow);
+        if (!hostedAllowlist.matches(channelEvent.message.channelId) &&
+            hostedAllowlist.unresolvedNames().length > 0) {
+            hostedAllowlistReady ??= resolveHostedAllowlistNames(hostedAllowlist);
+            await hostedAllowlistReady;
+        }
+        const botUserId = parseEventBodyBotUserId(payload);
+        return createChannelPostWatcher({
+            // Admission answers before a debounce timer could fire; edits arrive
+            // as their own deliveries and the edge drops them.
+            options: { ...channelPosts, debounceMs: 0 },
+            allowlist: hostedAllowlist,
+            getBotUserId: () => botUserId,
+            log: getLog(),
+            dispatch: (message, eventId) => {
+                args.waitUntil(dispatchInboundMessage({
+                    kind: "channel_post",
+                    message,
+                    handler: onChannelPost,
+                    propagateHandlerErrors: true,
+                    send: args.send,
+                    credentials,
+                    host: args.host,
+                    artifacts: args.artifacts,
+                    log: getLog(),
+                    evalCommandsEnabled,
+                    followUpStatus,
+                    ack: reply.ack,
+                    blockExternals,
+                    continuation: options.continuation,
+                    ...(args.hasContinuationSession === undefined
                         ? {}
-                        : { hasContinuationSession: args.hasContinuationSession })), (args.isContinuationBusy === undefined
+                        : { hasContinuationSession: args.hasContinuationSession }),
+                    ...(args.isContinuationBusy === undefined
                         ? {}
-                        : { isContinuationBusy: args.isContinuationBusy })), (args.getContinuationLastBotMessageTs === undefined
+                        : { isContinuationBusy: args.isContinuationBusy }),
+                    ...(args.getContinuationLastBotMessageTs === undefined
                         ? {}
                         : {
                             getContinuationLastBotMessageTs: args.getContinuationLastBotMessageTs,
-                        })), (args.interruptContinuation === undefined
+                        }),
+                    ...(args.interruptContinuation === undefined
                         ? {}
-                        : { interruptContinuation: args.interruptContinuation })), (eventId === undefined ? {} : { eventId })), (platformHandoff === undefined ? {} : { platformHandoff }))));
-                },
-            });
+                        : { interruptContinuation: args.interruptContinuation }),
+                    ...(eventId === undefined ? {} : { eventId }),
+                    ...(platformHandoff === undefined ? {} : { platformHandoff }),
+                }));
+            },
         });
     }
+    /**
+     * A hosted Block Kit click: the control plane verified the interactivity
+     * payload and pinned its `team.id` to the app's install workspace, which is
+     * the baseline the external-sender gate needs (Socket Mode reads it from
+     * `auth.test`). Tool-approval clicks skip: their parked call lives in the
+     * executing fork, queued ahead of this delivery on the same thread lane.
+     */
+    function dispatchHostedBlockAction(payload, args) {
+        const action = parseSlackBlockAction(payload);
+        if (action === null || onBlockAction === undefined) {
+            return skipped("not_dispatchable");
+        }
+        const approvalDecision = decisionFromActionId(action.actionId) ?? decisionFromAuthActionId(action.actionId);
+        if (approvalDecision !== null && parseApprovalActionValue(action.value) !== null) {
+            getLog().info("block action skipped (tool approvals are not resolved on hosted v2)", {
+                action_id: action.actionId,
+                channel: action.channelId,
+            });
+            return skipped("not_dispatchable");
+        }
+        args.waitUntil(dispatchBlockAction(payload, {
+            handler: onBlockAction,
+            send: args.send,
+            credentials,
+            host: args.host,
+            artifacts: args.artifacts,
+            log: getLog(),
+            blockExternals,
+            installTeamId: action.teamId,
+            hasContinuationSession: args.hasContinuationSession,
+            isContinuationBusy: args.isContinuationBusy,
+            getContinuationLastBotMessageTs: args.getContinuationLastBotMessageTs,
+            interruptContinuation: args.interruptContinuation,
+            continuation: options.continuation,
+            propagateHandlerErrors: true,
+        }));
+        return skipped("not_engaged");
+    }
     function inboundDeps(args) {
-        var _a, _b;
-        const watch = (_a = args.channelWatch) !== null && _a !== void 0 ? _a : channelWatch;
-        return Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({ send: args.send, continuation: options.continuation, waitUntil: args.waitUntil, onAppMention,
-            onDirectMessage }, (onReactionAdded === undefined ? {} : { onReactionAdded })), { credentials, eventIds: (_b = args.eventIds) !== null && _b !== void 0 ? _b : eventIds, propagateHandlerErrors: args.propagateHandlerErrors, host: args.host, artifacts: args.artifacts, log: getLog(), mentionsEnabled,
+        const watch = args.channelWatch ?? channelWatch;
+        return {
+            send: args.send,
+            continuation: options.continuation,
+            waitUntil: args.waitUntil,
+            onAppMention,
+            onDirectMessage,
+            ...(onReactionAdded === undefined ? {} : { onReactionAdded }),
+            credentials,
+            eventIds: args.eventIds ?? eventIds,
+            propagateHandlerErrors: args.propagateHandlerErrors,
+            host: args.host,
+            artifacts: args.artifacts,
+            log: getLog(),
+            mentionsEnabled,
             directMessagesEnabled,
             evalCommandsEnabled,
-            followUpStatus, ack: reply.ack, placeholder: reply.placeholder, blockExternals }), (args.platformHandoff === undefined ? {} : { platformHandoff: args.platformHandoff })), (args.hasContinuationSession === undefined
-            ? {}
-            : { hasContinuationSession: args.hasContinuationSession })), (args.isContinuationBusy === undefined
-            ? {}
-            : { isContinuationBusy: args.isContinuationBusy })), (args.getContinuationLastBotMessageTs === undefined
-            ? {}
-            : {
-                getContinuationLastBotMessageTs: args.getContinuationLastBotMessageTs,
-            })), (args.interruptContinuation === undefined
-            ? {}
-            : { interruptContinuation: args.interruptContinuation })), (watch === undefined ? {} : { channelWatch: watch })), (botMentionGate === undefined ? {} : { botMentionGate })), { suggestedPrompts: options.suggestedPrompts, suggestedPromptsTitle: options.suggestedPromptsTitle });
+            followUpStatus,
+            ack: reply.ack,
+            placeholder: reply.placeholder,
+            blockExternals,
+            ...(args.platformHandoff === undefined ? {} : { platformHandoff: args.platformHandoff }),
+            ...(args.hasContinuationSession === undefined
+                ? {}
+                : { hasContinuationSession: args.hasContinuationSession }),
+            ...(args.isContinuationBusy === undefined
+                ? {}
+                : { isContinuationBusy: args.isContinuationBusy }),
+            ...(args.getContinuationLastBotMessageTs === undefined
+                ? {}
+                : {
+                    getContinuationLastBotMessageTs: args.getContinuationLastBotMessageTs,
+                }),
+            ...(args.interruptContinuation === undefined
+                ? {}
+                : { interruptContinuation: args.interruptContinuation }),
+            ...(watch === undefined ? {} : { channelWatch: watch }),
+            ...(botMentionGate === undefined ? {} : { botMentionGate }),
+            suggestedPrompts: options.suggestedPrompts,
+            suggestedPromptsTitle: options.suggestedPromptsTitle,
+        };
     }
     const definition = defineChannel({
         auth: [allowAll()],
         state: emptySlackChannelState(),
         routes: [],
-        meta: Object.assign(Object.assign(Object.assign({ kind: "slack", 
+        meta: {
+            kind: "slack",
             // Omitted (not empty) when nothing dispatches, so fanout never
             // materializes a subscription with no event types.
-            slackEventTypes: slackEventTypes.length === 0 ? undefined : slackEventTypes }, (reply.mode === "agentic"
-            ? {
-                slackReply: Object.assign({ mode: "agentic", ack: (_g = reply.ack) !== null && _g !== void 0 ? _g : DEFAULT_ACK }, (reply.placeholder === undefined
-                    ? {}
-                    : {
-                        placeholder: reply.placeholder,
-                    })),
-            }
-            : {})), (channelPosts === undefined || channelPostsWatchEverywhere(channelPosts.allow)
-            ? {}
-            : { slackChannelPosts: [...channelPosts.allow] })), { deprecations: reply.deprecations }),
-        receive(input_1, _a) {
-            return __awaiter(this, arguments, void 0, function* (input, { send }) {
-                var _b;
-                const target = (_b = input.target) !== null && _b !== void 0 ? _b : {};
-                const channelId = typeof target.channelId === "string" ? target.channelId : "";
-                if (channelId === "") {
-                    throw new Error("slackChannel().receive requires target.channelId (Slack channel id).");
-                }
-                const threadTs = typeof target.threadTs === "string" ? target.threadTs : "";
-                if (threadTs === "") {
-                    throw new Error("slackChannel().receive requires target.threadTs (Slack thread ts).");
+            slackEventTypes: slackEventTypes.length === 0 ? undefined : slackEventTypes,
+            ...(reply.mode === "agentic"
+                ? {
+                    slackReply: {
+                        mode: "agentic",
+                        ack: reply.ack ?? DEFAULT_ACK,
+                        ...(reply.placeholder === undefined
+                            ? {}
+                            : {
+                                placeholder: reply.placeholder,
+                            }),
+                    },
                 }
-                const teamId = typeof target.teamId === "string" ? target.teamId : undefined;
-                getLog().info("receive handoff", {
-                    channel: channelId,
-                    thread_ts: threadTs,
-                    team: teamId,
-                });
-                const state = emptySlackChannelState({
-                    channelId,
-                    threadTs,
-                    teamId: teamId !== null && teamId !== void 0 ? teamId : null,
-                });
-                return send(input.message, Object.assign(Object.assign({ auth: input.auth, admission: "coalesce" }, (continuationSource(options.continuation, "slack") === "control-plane"
+                : {}),
+            // A lone "*" stays off the manifest. Hosting already delivers a reply
+            // in a thread a mention started; publishing "*" is what the control
+            // plane rejects.
+            ...(channelPosts === undefined || channelPostsWatchEverywhere(channelPosts.allow)
+                ? {}
+                : { slackChannelPosts: [...channelPosts.allow] }),
+            deprecations: reply.deprecations,
+        },
+        async receive(input, { send }) {
+            const target = input.target ?? {};
+            const channelId = typeof target.channelId === "string" ? target.channelId : "";
+            if (channelId === "") {
+                throw new Error("slackChannel().receive requires target.channelId (Slack channel id).");
+            }
+            const threadTs = typeof target.threadTs === "string" ? target.threadTs : "";
+            if (threadTs === "") {
+                throw new Error("slackChannel().receive requires target.threadTs (Slack thread ts).");
+            }
+            const teamId = typeof target.teamId === "string" ? target.teamId : undefined;
+            getLog().info("receive handoff", {
+                channel: channelId,
+                thread_ts: threadTs,
+                team: teamId,
+            });
+            const state = emptySlackChannelState({
+                channelId,
+                threadTs,
+                teamId: teamId ?? null,
+            });
+            return send(input.message, {
+                auth: input.auth,
+                admission: "coalesce",
+                ...(continuationSource(options.continuation, "slack") === "control-plane"
                     ? {
                         claim: {
                             type: "thread",
@@ -310,203 +400,228 @@ export function slackChannel(authored = {}) {
                     }
                     : {
                         continuationToken: slackContinuationKey(channelId, threadTs),
-                    })), { state, refreshState: slackWakeChannelState({
-                        channelId,
-                        threadTs,
-                        teamId: teamId !== null && teamId !== void 0 ? teamId : null,
-                    }) }));
+                    }),
+                state,
+                refreshState: slackWakeChannelState({
+                    channelId,
+                    threadTs,
+                    teamId: teamId ?? null,
+                }),
             });
         },
         events,
-        onStart(args) {
-            return __awaiter(this, void 0, void 0, function* () {
-                var _a, _b, _c, _d, _e, _f;
-                runtime.log = createSlackLogger((_a = args.logger) !== null && _a !== void 0 ? _a : options.logger);
-                // Cursor-managed v2 receives inbound events through the control-plane
-                // adapter attached below. Do not also start (or warn about) the local
-                // Socket Mode transport: hosted outbound replies need only the bot token.
-                if (args.architecture === "v2" && process.env[AGENT_SERVE_GENERATION_ENV_VAR] !== undefined) {
-                    getLog().info("channel start", { transport: "events-api" });
-                    return;
+        async onStart(args) {
+            runtime.log = createSlackLogger(args.logger ?? options.logger);
+            // Cursor-managed v2 receives inbound events through the control-plane
+            // adapter attached below. Do not also start (or warn about) the local
+            // Socket Mode transport: hosted outbound replies need only the bot token.
+            if (args.architecture === "v2" && process.env[AGENT_SERVE_GENERATION_ENV_VAR] !== undefined) {
+                getLog().info("channel start", { transport: "events-api" });
+                return;
+            }
+            getLog().info("channel start", { transport: "socket" });
+            const appToken = await tryResolveAppToken(credentials);
+            const botToken = await tryResolveBotToken(credentials);
+            if (appToken === undefined || botToken === undefined) {
+                getLog().info("channel idle", {
+                    reason: "missing credentials",
+                    need: `${envKeys.bot} and ${envKeys.app}`,
+                });
+                return;
+            }
+            let botUserId;
+            let botId;
+            let installTeamId;
+            let webClient = null;
+            if (channelPosts !== undefined || botMentions !== undefined || routeInteractive) {
+                try {
+                    const { WebClient } = await import("@slack/web-api");
+                    webClient = new WebClient(botToken);
+                    const identity = await webClient.auth.test();
+                    botUserId = typeof identity.user_id === "string" ? identity.user_id : undefined;
+                    botId = typeof identity.bot_id === "string" ? identity.bot_id : undefined;
+                    installTeamId = typeof identity.team_id === "string" ? identity.team_id : undefined;
                 }
-                getLog().info("channel start", { transport: "socket" });
-                const appToken = yield tryResolveAppToken(credentials);
-                const botToken = yield tryResolveBotToken(credentials);
-                if (appToken === undefined || botToken === undefined) {
-                    getLog().info("channel idle", {
-                        reason: "missing credentials",
-                        need: `${envKeys.bot} and ${envKeys.app}`,
+                catch (error) {
+                    getLog().error("bot identity lookup degraded", {
+                        error: error instanceof Error ? error.message : String(error),
                     });
-                    return;
                 }
-                let botUserId;
-                let botId;
-                let installTeamId;
-                let webClient = null;
-                if (channelPosts !== undefined || botMentions !== undefined || routeInteractive) {
-                    try {
-                        const { WebClient } = yield import("@slack/web-api");
-                        webClient = new WebClient(botToken);
-                        const identity = yield webClient.auth.test();
-                        botUserId = typeof identity.user_id === "string" ? identity.user_id : undefined;
-                        botId = typeof identity.bot_id === "string" ? identity.bot_id : undefined;
-                        installTeamId = typeof identity.team_id === "string" ? identity.team_id : undefined;
-                    }
-                    catch (error) {
-                        getLog().error("bot identity lookup degraded", {
-                            error: error instanceof Error ? error.message : String(error),
-                        });
-                    }
+            }
+            if (botMentions !== undefined) {
+                if (botUserId === undefined && botId === undefined) {
+                    getLog().error("bot mentions disabled", {
+                        reason: "engagement.botMentions requires bot identity from auth.test (loop safety)",
+                    });
                 }
-                if (botMentions !== undefined) {
-                    if (botUserId === undefined && botId === undefined) {
-                        getLog().error("bot mentions disabled", {
-                            reason: "engagement.botMentions requires bot identity from auth.test (loop safety)",
-                        });
-                    }
-                    else {
-                        botMentionGate = new SlackBotMentionGate(botMentions, { botUserId, botId }, { log: getLog() });
-                        getLog().info("bot mentions enabled", {
-                            allow_from: botMentions.allowFrom.join(","),
-                            max_depth: (_b = botMentions.maxDepth) !== null && _b !== void 0 ? _b : SLACK_BOT_MENTION_DEFAULTS.maxDepth,
-                            max_per_thread_per_hour: (_c = botMentions.maxPerThreadPerHour) !== null && _c !== void 0 ? _c : SLACK_BOT_MENTION_DEFAULTS.maxPerThreadPerHour,
-                            max_per_thread_total: (_d = botMentions.maxPerThreadTotal) !== null && _d !== void 0 ? _d : SLACK_BOT_MENTION_DEFAULTS.maxPerThreadTotal,
-                        });
-                    }
+                else {
+                    botMentionGate = new SlackBotMentionGate(botMentions, { botUserId, botId }, { log: getLog() });
+                    getLog().info("bot mentions enabled", {
+                        allow_from: botMentions.allowFrom.join(","),
+                        max_depth: botMentions.maxDepth ?? SLACK_BOT_MENTION_DEFAULTS.maxDepth,
+                        max_per_thread_per_hour: botMentions.maxPerThreadPerHour ?? SLACK_BOT_MENTION_DEFAULTS.maxPerThreadPerHour,
+                        max_per_thread_total: botMentions.maxPerThreadTotal ?? SLACK_BOT_MENTION_DEFAULTS.maxPerThreadTotal,
+                    });
                 }
-                if (channelPosts !== undefined) {
-                    const allowlist = new SlackChannelAllowlist(channelPosts.allow);
-                    try {
-                        const names = allowlist.unresolvedNames();
-                        if (names.length > 0 && webClient !== null) {
-                            allowlist.applyResolvedNames(yield resolveChannelNames(webClient, names, getLog()));
-                        }
-                    }
-                    catch (error) {
-                        getLog().error("channel watch setup degraded", {
-                            error: error instanceof Error ? error.message : String(error),
-                        });
-                    }
-                    if (channelPosts.includeBotPosts === true &&
-                        botUserId === undefined &&
-                        botId === undefined) {
-                        getLog().error("channel watch disabled", {
-                            reason: "includeBotPosts requires bot identity from auth.test (loop safety)",
-                        });
+            }
+            if (channelPosts !== undefined) {
+                const allowlist = new SlackChannelAllowlist(channelPosts.allow);
+                try {
+                    const names = allowlist.unresolvedNames();
+                    if (names.length > 0 && webClient !== null) {
+                        allowlist.applyResolvedNames(await resolveChannelNames(webClient, names, getLog()));
                     }
-                    else {
-                        channelWatch = createChannelPostWatcher({
-                            options: channelPosts,
-                            allowlist,
-                            getBotUserId: () => botUserId,
-                            getBotId: () => botId,
-                            log: getLog(),
-                            dispatch: (message, eventId) => {
-                                args.waitUntil(dispatchInboundMessage(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({ kind: "channel_post", message, handler: onChannelPost, send: args.send, credentials, host: args.host, artifacts: args.artifacts, log: getLog(), evalCommandsEnabled,
-                                    followUpStatus, ack: reply.ack, blockExternals, continuation: options.continuation }, (args.hasContinuationSession === undefined
+                }
+                catch (error) {
+                    getLog().error("channel watch setup degraded", {
+                        error: error instanceof Error ? error.message : String(error),
+                    });
+                }
+                if (channelPosts.includeBotPosts === true &&
+                    botUserId === undefined &&
+                    botId === undefined) {
+                    getLog().error("channel watch disabled", {
+                        reason: "includeBotPosts requires bot identity from auth.test (loop safety)",
+                    });
+                }
+                else {
+                    channelWatch = createChannelPostWatcher({
+                        options: channelPosts,
+                        allowlist,
+                        getBotUserId: () => botUserId,
+                        getBotId: () => botId,
+                        log: getLog(),
+                        dispatch: (message, eventId) => {
+                            args.waitUntil(dispatchInboundMessage({
+                                kind: "channel_post",
+                                message,
+                                handler: onChannelPost,
+                                send: args.send,
+                                credentials,
+                                host: args.host,
+                                artifacts: args.artifacts,
+                                log: getLog(),
+                                evalCommandsEnabled,
+                                followUpStatus,
+                                ack: reply.ack,
+                                blockExternals,
+                                continuation: options.continuation,
+                                ...(args.hasContinuationSession === undefined
                                     ? {}
                                     : {
                                         hasContinuationSession: args.hasContinuationSession,
-                                    })), (args.isContinuationBusy === undefined
+                                    }),
+                                ...(args.isContinuationBusy === undefined
                                     ? {}
-                                    : { isContinuationBusy: args.isContinuationBusy })), (args.getContinuationLastBotMessageTs === undefined
+                                    : { isContinuationBusy: args.isContinuationBusy }),
+                                ...(args.getContinuationLastBotMessageTs === undefined
                                     ? {}
                                     : {
                                         getContinuationLastBotMessageTs: args.getContinuationLastBotMessageTs,
-                                    })), (args.interruptContinuation === undefined
+                                    }),
+                                ...(args.interruptContinuation === undefined
                                     ? {}
                                     : {
                                         interruptContinuation: args.interruptContinuation,
-                                    })), (eventId === undefined ? {} : { eventId }))));
-                            },
-                        });
-                        getLog().info("channel watch enabled", {
-                            channels: channelPosts.allow.join(","),
-                            posts: (_e = channelPosts.posts) !== null && _e !== void 0 ? _e : "top-level",
-                            debounce_ms: (_f = channelPosts.debounceMs) !== null && _f !== void 0 ? _f : 0,
-                        });
-                    }
+                                    }),
+                                ...(eventId === undefined ? {} : { eventId }),
+                            }));
+                        },
+                    });
+                    getLog().info("channel watch enabled", {
+                        channels: channelPosts.allow.join(","),
+                        posts: channelPosts.posts ?? "top-level",
+                        debounce_ms: channelPosts.debounceMs ?? 0,
+                    });
                 }
-                const socketOptions = {
-                    appToken,
-                    logger: line => getLog().write(line),
-                    onEvent: payload => {
-                        dispatchInboundFromEventBody(payload, inboundDeps(Object.assign(Object.assign(Object.assign(Object.assign({ send: args.send, waitUntil: args.waitUntil, host: args.host, artifacts: args.artifacts }, (args.hasContinuationSession === undefined
+            }
+            const socketOptions = {
+                appToken,
+                logger: line => getLog().write(line),
+                onEvent: payload => {
+                    dispatchInboundFromEventBody(payload, inboundDeps({
+                        send: args.send,
+                        waitUntil: args.waitUntil,
+                        host: args.host,
+                        artifacts: args.artifacts,
+                        ...(args.hasContinuationSession === undefined
                             ? {}
-                            : { hasContinuationSession: args.hasContinuationSession })), (args.isContinuationBusy === undefined
+                            : { hasContinuationSession: args.hasContinuationSession }),
+                        ...(args.isContinuationBusy === undefined
                             ? {}
-                            : { isContinuationBusy: args.isContinuationBusy })), (args.getContinuationLastBotMessageTs === undefined
+                            : { isContinuationBusy: args.isContinuationBusy }),
+                        ...(args.getContinuationLastBotMessageTs === undefined
                             ? {}
                             : {
                                 getContinuationLastBotMessageTs: args.getContinuationLastBotMessageTs,
-                            })), (args.interruptContinuation === undefined
+                            }),
+                        ...(args.interruptContinuation === undefined
                             ? {}
-                            : { interruptContinuation: args.interruptContinuation }))));
-                    },
-                };
-                if (routeInteractive) {
-                    socketOptions.onInteractive = (payload) => __awaiter(this, void 0, void 0, function* () {
-                        // Framework tool-approval Approve/Deny clicks resolve first;
-                        // anything else (including approval-shaped clicks whose value
-                        // fails to parse) falls through to the author's block-action hook.
-                        const handledAsApproval = yield dispatchInteractiveFromPayload(payload, {
-                            credentials,
-                            getSession: args.getSession,
-                            resolveApproval: args.resolveApproval,
-                            resolveAuth: args.resolveAuth,
-                            waitUntil: args.waitUntil,
-                            log: getLog(),
-                            blockExternals,
-                        });
-                        if (handledAsApproval || onBlockAction === undefined) {
-                            return;
-                        }
-                        yield dispatchBlockAction(payload, {
-                            handler: onBlockAction,
-                            send: args.send,
-                            credentials,
-                            host: args.host,
-                            artifacts: args.artifacts,
-                            log: getLog(),
-                            blockExternals,
-                            installTeamId,
-                            hasContinuationSession: args.hasContinuationSession,
-                            isContinuationBusy: args.isContinuationBusy,
-                            getContinuationLastBotMessageTs: args.getContinuationLastBotMessageTs,
-                            interruptContinuation: args.interruptContinuation,
-                            continuation: options.continuation,
-                        });
+                            : { interruptContinuation: args.interruptContinuation }),
+                    }));
+                },
+            };
+            if (routeInteractive) {
+                socketOptions.onInteractive = async (payload) => {
+                    // Framework tool-approval Approve/Deny clicks resolve first;
+                    // anything else (including approval-shaped clicks whose value
+                    // fails to parse) falls through to the author's block-action hook.
+                    const handledAsApproval = await dispatchInteractiveFromPayload(payload, {
+                        credentials,
+                        getSession: args.getSession,
+                        resolveApproval: args.resolveApproval,
+                        resolveAuth: args.resolveAuth,
+                        waitUntil: args.waitUntil,
+                        log: getLog(),
+                        blockExternals,
                     });
-                }
-                try {
-                    socketHandle = yield startSlackSocketMode(socketOptions);
-                }
-                catch (error) {
-                    // Bad Vault tokens / revoked apps: Socket Mode fails once with
-                    // invalid_auth and does not reconnect. Treat as idle so one bad
-                    // Slack pack does not blow up server start with a stack dump.
-                    const message = error instanceof Error ? error.message : String(error);
-                    if (message.includes("invalid_auth") || message.includes("not_authed")) {
-                        getLog().info("channel idle", {
-                            reason: "invalid credentials",
-                            need: `${envKeys.bot} and ${envKeys.app}`,
-                        });
+                    if (handledAsApproval || onBlockAction === undefined) {
                         return;
                     }
-                    throw error;
+                    await dispatchBlockAction(payload, {
+                        handler: onBlockAction,
+                        send: args.send,
+                        credentials,
+                        host: args.host,
+                        artifacts: args.artifacts,
+                        log: getLog(),
+                        blockExternals,
+                        installTeamId,
+                        hasContinuationSession: args.hasContinuationSession,
+                        isContinuationBusy: args.isContinuationBusy,
+                        getContinuationLastBotMessageTs: args.getContinuationLastBotMessageTs,
+                        interruptContinuation: args.interruptContinuation,
+                        continuation: options.continuation,
+                    });
+                };
+            }
+            try {
+                socketHandle = await startSlackSocketMode(socketOptions);
+            }
+            catch (error) {
+                // Bad Vault tokens / revoked apps: Socket Mode fails once with
+                // invalid_auth and does not reconnect. Treat as idle so one bad
+                // Slack pack does not blow up server start with a stack dump.
+                const message = error instanceof Error ? error.message : String(error);
+                if (message.includes("invalid_auth") || message.includes("not_authed")) {
+                    getLog().info("channel idle", {
+                        reason: "invalid credentials",
+                        need: `${envKeys.bot} and ${envKeys.app}`,
+                    });
+                    return;
                 }
-            });
+                throw error;
+            }
         },
-        onStop: () => __awaiter(this, void 0, void 0, function* () {
-            var _a;
+        onStop: async () => {
             getLog().info("channel stop");
-            channelWatch === null || channelWatch === void 0 ? void 0 : channelWatch.stop();
+            channelWatch?.stop();
             channelWatch = undefined;
             botMentionGate = undefined;
-            yield socketHandle === null || socketHandle === void 0 ? void 0 : socketHandle.stop();
+            await socketHandle?.stop();
             socketHandle = null;
-            yield (_a = options.onStop) === null || _a === void 0 ? void 0 : _a.call(options);
-        }),
+            await options.onStop?.();
+        },
     });
     slackChannelOptionsByDefinition.set(definition, options);
     attachHostedAdmissionAdapter(definition, {
@@ -523,12 +638,30 @@ export function slackChannel(authored = {}) {
         // fresh instance per delivery: the control plane's app-scoped ingress
         // claim already dedupes Slack retries, and on a warm pod the local set
         // would otherwise swallow the control plane's own retry of a delivery
-        // that failed after the id was marked handled.
-        dispatch: (_a) => __awaiter(this, [_a], void 0, function* ({ payload, args, platformHandoff }) {
-            const hostedWatch = yield hostedChannelWatch(payload, args, platformHandoff);
-            const dispatched = dispatchInboundFromEventBody(payload, inboundDeps(Object.assign(Object.assign({ send: args.send, waitUntil: args.waitUntil, host: args.host, artifacts: args.artifacts, eventIds: createEventIdDedupe(), propagateHandlerErrors: true, hasContinuationSession: args.hasContinuationSession, isContinuationBusy: args.isContinuationBusy, getContinuationLastBotMessageTs: args.getContinuationLastBotMessageTs, interruptContinuation: args.interruptContinuation }, (platformHandoff === undefined ? {} : { platformHandoff })), (hostedWatch === undefined ? {} : { channelWatch: hostedWatch }))));
+        // that failed after the id was marked handled. A `block_actions`
+        // delivery carries the interactivity payload instead and takes the
+        // Socket Mode Block Kit path.
+        dispatch: async ({ eventType, payload, args, platformHandoff }) => {
+            if (eventType === "block_actions") {
+                return dispatchHostedBlockAction(payload, args);
+            }
+            const hostedWatch = await hostedChannelWatch(payload, args, platformHandoff);
+            const dispatched = dispatchInboundFromEventBody(payload, inboundDeps({
+                send: args.send,
+                waitUntil: args.waitUntil,
+                host: args.host,
+                artifacts: args.artifacts,
+                eventIds: createEventIdDedupe(),
+                propagateHandlerErrors: true,
+                hasContinuationSession: args.hasContinuationSession,
+                isContinuationBusy: args.isContinuationBusy,
+                getContinuationLastBotMessageTs: args.getContinuationLastBotMessageTs,
+                interruptContinuation: args.interruptContinuation,
+                ...(platformHandoff === undefined ? {} : { platformHandoff }),
+                ...(hostedWatch === undefined ? {} : { channelWatch: hostedWatch }),
+            }));
             return skipped(dispatched ? "not_engaged" : "not_dispatchable");
-        }),
+        },
     });
     return definition;
 }