@cursor/bdk 0.2.9 → 0.2.11

package/dist/channels/slack/dispatch.js

@@ -1,15 +1,6 @@
 /**
  * Shared inbound dispatch for Slack Events API bodies and Socket Mode.
  */
-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 { continuationSource, normalizeIdentity, } from "../../internal/continuation-identity.js";
 import { isDeferredChannelSession } from "../../internal/deferred-channel-session.js";
 import { routeLocalIngressContinuation } from "../../internal/local-ingress.js";
@@ -26,7 +17,7 @@ import { defaultSlackLog } from "./log.js";
 import { paintTurnStart, retractTurnStart } from "./paint-start.js";
 import { adoptPlaceholder, retractPlaceholderMessage, retractPlaceholderSlot, startPlaceholder, } from "./placeholder.js";
 import { resolveSlackSelfIdentity } from "./self-identity.js";
-import { resolveSlackSenderName } from "./sender-name.js";
+import { resolveSlackSender } from "./sender-name.js";
 import { isWholeMessageStop } from "./stop.js";
 import { EMPTY_SLACK_THREAD_CONTEXT, loadSlackThreadContext, loadSlackThreadDelta, } from "./thread-context.js";
 const FOLLOWUP_TYPING = "Saw your follow-up…";
@@ -42,38 +33,61 @@ function slackUserText(message, override) {
     }
     return message.markdown;
 }
-function slackTurnMedia(args) {
-    return __awaiter(this, void 0, void 0, function* () {
-        var _a, _b, _c, _d;
-        const messageFiles = (_a = args.message.files) !== null && _a !== void 0 ? _a : [];
-        const prepared = messageFiles.length > 0 || args.threadFiles.length > 0
-            ? yield prepareSlackAttachments({
-                botToken: args.botToken,
-                files: messageFiles,
-                threadFiles: args.threadFiles,
-                log: args.log,
-            })
-            : undefined;
-        const workspaceFiles = Object.assign(Object.assign({}, args.decision.workspaceFiles), prepared === null || prepared === void 0 ? void 0 : prepared.workspaceFiles);
-        const images = [...((_b = args.decision.images) !== null && _b !== void 0 ? _b : []), ...((_c = prepared === null || prepared === void 0 ? void 0 : prepared.images) !== null && _c !== void 0 ? _c : [])];
-        return {
-            userText: appendSlackAttachmentAnnotations(slackUserText(args.message, args.decision.message), (_d = prepared === null || prepared === void 0 ? void 0 : prepared.annotations) !== null && _d !== void 0 ? _d : [], messageFiles.length > 0 ? SLACK_ATTACHMENT_ONLY_PROMPT : ""),
-            workspaceFiles: Object.keys(workspaceFiles).length > 0 ? workspaceFiles : undefined,
-            images: images.length > 0 ? images : undefined,
-        };
-    });
+async function slackTurnMedia(args) {
+    const messageFiles = args.message.files ?? [];
+    const prepared = messageFiles.length > 0 || args.threadFiles.length > 0
+        ? await prepareSlackAttachments({
+            botToken: args.botToken,
+            files: messageFiles,
+            threadFiles: args.threadFiles,
+            log: args.log,
+        })
+        : undefined;
+    const workspaceFiles = {
+        ...args.decision.workspaceFiles,
+        ...prepared?.workspaceFiles,
+    };
+    const images = [...(args.decision.images ?? []), ...(prepared?.images ?? [])];
+    return {
+        userText: appendSlackAttachmentAnnotations(slackUserText(args.message, args.decision.message), prepared?.annotations ?? [], messageFiles.length > 0 ? SLACK_ATTACHMENT_ONLY_PROMPT : ""),
+        workspaceFiles: Object.keys(workspaceFiles).length > 0 ? workspaceFiles : undefined,
+        images: images.length > 0 ? images : undefined,
+    };
 }
 /** Blank per-session adapter state. */
 export function emptySlackChannelState(patch = {}) {
-    return Object.assign({ channelId: null, threadTs: null, teamId: null, triggeringUserId: null, pendingToolCallMessage: null, lastReasoningTypingAtMs: null, lastReasoningTypingStatus: null, streamTs: null, streamChannelId: null, lastPostedText: null, streamBlockText: null, lastBotMessageTs: null, streamingUnavailable: false, streamFull: false, streamAppendedChunks: 0, progressTs: null, approvalMessageByCallId: {}, reasoningCard: undefined, toolCardCounts: {}, agenticFiles: [], startPainted: false, turnStartedAtMs: null }, patch);
+    return {
+        channelId: null,
+        threadTs: null,
+        teamId: null,
+        triggeringUserId: null,
+        pendingToolCallMessage: null,
+        lastReasoningTypingAtMs: null,
+        lastReasoningTypingStatus: null,
+        streamTs: null,
+        streamChannelId: null,
+        lastPostedText: null,
+        streamBlockText: null,
+        lastBotMessageTs: null,
+        streamingUnavailable: false,
+        streamFull: false,
+        streamAppendedChunks: 0,
+        progressTs: null,
+        approvalMessageByCallId: {},
+        reasoningCard: undefined,
+        toolCardCounts: {},
+        agenticFiles: [],
+        startPainted: false,
+        turnStartedAtMs: null,
+        ...patch,
+    };
 }
 export function slackWakeChannelState(args) {
-    var _a, _b;
     const wake = {
         channelId: args.channelId,
         threadTs: args.threadTs,
-        teamId: (_a = args.teamId) !== null && _a !== void 0 ? _a : null,
-        triggeringUserId: (_b = args.triggeringUserId) !== null && _b !== void 0 ? _b : null,
+        teamId: args.teamId ?? null,
+        triggeringUserId: args.triggeringUserId ?? null,
         placeholderPosted: args.placeholderPosted === true,
     };
     if (args.startPainted === true) {
@@ -82,32 +96,59 @@ export function slackWakeChannelState(args) {
     return wake;
 }
 function triggeringMergeMessage(message) {
-    var _a, _b;
-    return Object.assign(Object.assign(Object.assign({ ts: message.ts }, (((_a = message.author) === null || _a === void 0 ? void 0 : _a.userId) === undefined || message.author.userId === ""
-        ? {}
-        : { user: message.author.userId })), (((_b = message.author) === null || _b === void 0 ? void 0 : _b.botId) === undefined ? {} : { bot_id: message.author.botId })), { 
+    return {
+        ts: message.ts,
+        ...(message.author?.userId === undefined || message.author.userId === ""
+            ? {}
+            : { user: message.author.userId }),
+        ...(message.author?.botId === undefined ? {} : { bot_id: message.author.botId }),
         // Flattened body, so this stand-in matches what the real API record
         // reduces to and is not dropped as empty by the thread-context filters.
-        text: message.body });
+        text: message.body,
+    };
 }
 function continuationArg(identity) {
     return identity === undefined ? {} : { continuation: identity };
 }
 function inboundContinuation(deps) {
-    return Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, continuationArg(deps.continuation)), (deps.hasContinuationSession === undefined
-        ? {}
-        : { hasContinuationSession: deps.hasContinuationSession })), (deps.isContinuationBusy === undefined
-        ? {}
-        : { isContinuationBusy: deps.isContinuationBusy })), (deps.getContinuationLastBotMessageTs === undefined
-        ? {}
-        : {
-            getContinuationLastBotMessageTs: deps.getContinuationLastBotMessageTs,
-        })), (deps.interruptContinuation === undefined
-        ? {}
-        : { interruptContinuation: deps.interruptContinuation }));
+    return {
+        ...continuationArg(deps.continuation),
+        ...(deps.hasContinuationSession === undefined
+            ? {}
+            : { hasContinuationSession: deps.hasContinuationSession }),
+        ...(deps.isContinuationBusy === undefined
+            ? {}
+            : { isContinuationBusy: deps.isContinuationBusy }),
+        ...(deps.getContinuationLastBotMessageTs === undefined
+            ? {}
+            : {
+                getContinuationLastBotMessageTs: deps.getContinuationLastBotMessageTs,
+            }),
+        ...(deps.interruptContinuation === undefined
+            ? {}
+            : { interruptContinuation: deps.interruptContinuation }),
+    };
 }
 function scheduleInbound(deps, log, args) {
-    deps.waitUntil(dispatchInboundMessage(Object.assign(Object.assign(Object.assign({ kind: args.kind, message: args.message, handler: args.handler, propagateHandlerErrors: deps.propagateHandlerErrors, send: deps.send, credentials: deps.credentials, host: deps.host, artifacts: deps.artifacts, log, evalCommandsEnabled: args.evalCommandsEnabled, followUpStatus: deps.followUpStatus, ack: deps.ack, placeholder: deps.placeholder, blockExternals: deps.blockExternals }, inboundContinuation(deps)), (args.eventId === undefined ? {} : { eventId: args.eventId })), (args.platformHandoff === undefined ? {} : { platformHandoff: args.platformHandoff }))));
+    deps.waitUntil(dispatchInboundMessage({
+        kind: args.kind,
+        message: args.message,
+        handler: args.handler,
+        propagateHandlerErrors: deps.propagateHandlerErrors,
+        send: deps.send,
+        credentials: deps.credentials,
+        host: deps.host,
+        artifacts: deps.artifacts,
+        log,
+        evalCommandsEnabled: args.evalCommandsEnabled,
+        followUpStatus: deps.followUpStatus,
+        ack: deps.ack,
+        placeholder: deps.placeholder,
+        blockExternals: deps.blockExternals,
+        ...inboundContinuation(deps),
+        ...(args.eventId === undefined ? {} : { eventId: args.eventId }),
+        ...(args.platformHandoff === undefined ? {} : { platformHandoff: args.platformHandoff }),
+    }));
 }
 function slackSessionContinuation(identity, channelId, threadTs) {
     if (continuationSource(identity, "slack") === "engine") {
@@ -126,457 +167,489 @@ function slackSessionContinuation(identity, channelId, threadTs) {
     }
     return { probeKey: mailbox.key, sendPatch: { mailboxContinuation: mailbox } };
 }
-export function dispatchInboundMessage(args) {
-    return __awaiter(this, void 0, void 0, function* () {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0, _1, _2, _3, _4, _5;
-        var _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20;
-        const { message, kind } = args;
-        const log = (_6 = args.log) !== null && _6 !== void 0 ? _6 : defaultSlackLog;
-        const binding = buildSlackBinding({
-            botToken: (_a = args.credentials) === null || _a === void 0 ? void 0 : _a.botToken,
-            channelId: message.channelId,
-            threadTs: message.threadTs,
-            host: args.host,
-            artifacts: args.artifacts,
+export async function dispatchInboundMessage(args) {
+    const { message, kind } = args;
+    const log = args.log ?? defaultSlackLog;
+    const binding = buildSlackBinding({
+        botToken: args.credentials?.botToken,
+        channelId: message.channelId,
+        threadTs: message.threadTs,
+        host: args.host,
+        artifacts: args.artifacts,
+        log,
+        teamId: message.teamId,
+    });
+    log.info("inbound", {
+        kind,
+        event_id: args.eventId,
+        channel: message.channelId,
+        thread_ts: message.threadTs,
+        message_ts: message.ts,
+        user: message.author?.userId,
+        team: message.teamId,
+    });
+    const handoff = args.platformHandoff?.slackPlaceholder;
+    const handoffInThread = kind !== "channel_post" &&
+        handoff !== undefined &&
+        handoff.channelId === message.channelId &&
+        handoff.threadTs === message.threadTs
+        ? handoff
+        : undefined;
+    const matchedHandoff = args.placeholder !== undefined ? handoffInThread : undefined;
+    let adoptedPlaceholder = false;
+    let handoffRetracted = false;
+    const retractUnadoptedHandoff = async () => {
+        if (matchedHandoff === undefined || handoffRetracted) {
+            return;
+        }
+        handoffRetracted = true;
+        await retractPlaceholderMessage({
+            botToken: args.credentials?.botToken,
+            channelId: matchedHandoff.channelId,
+            ts: matchedHandoff.messageTs,
+            streamed: matchedHandoff.streamed,
             log,
-            teamId: message.teamId,
-        });
-        log.info("inbound", {
-            kind,
-            event_id: args.eventId,
-            channel: message.channelId,
-            thread_ts: message.threadTs,
-            message_ts: message.ts,
-            user: (_b = message.author) === null || _b === void 0 ? void 0 : _b.userId,
-            team: message.teamId,
         });
-        const handoff = (_c = args.platformHandoff) === null || _c === void 0 ? void 0 : _c.slackPlaceholder;
-        const handoffInThread = kind !== "channel_post" &&
-            handoff !== undefined &&
-            handoff.channelId === message.channelId &&
-            handoff.threadTs === message.threadTs
-            ? handoff
-            : undefined;
-        const matchedHandoff = args.placeholder !== undefined ? handoffInThread : undefined;
-        let adoptedPlaceholder = false;
-        let handoffRetracted = false;
-        const retractUnadoptedHandoff = () => __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            if (matchedHandoff === undefined || handoffRetracted) {
-                return;
-            }
-            handoffRetracted = true;
-            yield retractPlaceholderMessage({
-                botToken: (_a = args.credentials) === null || _a === void 0 ? void 0 : _a.botToken,
-                channelId: matchedHandoff.channelId,
-                ts: matchedHandoff.messageTs,
-                streamed: matchedHandoff.streamed,
-                log,
-            });
-        });
-        const adoptMatchedHandoff = () => __awaiter(this, void 0, void 0, function* () {
-            if (matchedHandoff === undefined) {
-                return;
-            }
-            const adoption = adoptPlaceholder({
-                channelId: matchedHandoff.channelId,
-                threadTs: matchedHandoff.threadTs,
-                ts: matchedHandoff.messageTs,
-                streamed: matchedHandoff.streamed,
-            });
-            if (adoption === "adopted") {
-                adoptedPlaceholder = true;
-                log.info("placeholder adopted from control-plane handoff", {
-                    channel: message.channelId,
-                    thread_ts: message.threadTs,
-                    message_ts: matchedHandoff.messageTs,
-                });
-                return;
-            }
-            if (adoption === "occupied") {
-                // Another delivery owns this thread's slot. Remove only this delivery's
-                // redundant CP post.
-                yield retractUnadoptedHandoff();
-            }
-        });
-        const retractAdoptedPlaceholder = () => __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            if (!adoptedPlaceholder) {
-                return;
-            }
-            adoptedPlaceholder = false;
-            yield retractPlaceholderSlot({
-                channelId: message.channelId,
-                threadTs: message.threadTs,
-                botToken: (_a = args.credentials) === null || _a === void 0 ? void 0 : _a.botToken,
-                log,
-            });
-        });
-        const userId = (_7 = (_d = message.author) === null || _d === void 0 ? void 0 : _d.userId) !== null && _7 !== void 0 ? _7 : "";
-        const teamId = message.teamId;
-        let membership;
-        if (args.blockExternals !== false && ((_e = message.author) === null || _e === void 0 ? void 0 : _e.isBot) !== true) {
-            if (teamId === undefined || teamId === "") {
-                log.info("inbound dropped (missing team)", {
-                    kind,
-                    channel: message.channelId,
-                    thread_ts: message.threadTs,
-                    user: userId,
-                    event_id: args.eventId,
-                });
-                yield retractUnadoptedHandoff();
-                return;
-            }
-            membership = isExternalSlackSender({
-                botToken: (_f = args.credentials) === null || _f === void 0 ? void 0 : _f.botToken,
-                slackTeamId: teamId,
-                userId,
-            });
-        }
-        const dropExternal = () => {
-            log.info("inbound dropped (external sender)", {
-                kind,
-                channel: message.channelId,
-                thread_ts: message.threadTs,
-                user: userId,
-                team: teamId,
-                event_id: args.eventId,
-            });
-        };
-        const { probeKey: continuation, sendPatch } = slackSessionContinuation(args.continuation, message.channelId, message.threadTs);
-        const loadThread = !isSlackImChannel(message.channelId);
-        const hosted = args.propagateHandlerErrors === true;
-        const existsP = args.hasContinuationSession === undefined || (!loadThread && !hosted)
-            ? undefined
-            : args.hasContinuationSession(continuation);
-        // Whole-message stop: cancel active turn + clear nudges (Benny parity).
-        if (isWholeMessageStop(message.text) || isWholeMessageStop(message.markdown)) {
-            if (membership !== undefined && (yield membership)) {
-                dropExternal();
-                yield retractUnadoptedHandoff();
-                return;
-            }
-            log.info("stop directive", {
-                kind,
-                channel: message.channelId,
-                thread_ts: message.threadTs,
-                continuation,
-                event_id: args.eventId,
-            });
-            yield (_g = args.host.slackNudges) === null || _g === void 0 ? void 0 : _g.clear(continuation);
-            const interrupted = args.interruptContinuation === undefined
-                ? false
-                : yield args.interruptContinuation(continuation);
-            try {
-                yield binding.thread.startTyping(interrupted ? "Stopped." : "Nothing to stop.");
-            }
-            catch (_21) {
-                // best-effort status
-            }
-            yield retractUnadoptedHandoff();
+    };
+    const adoptMatchedHandoff = async () => {
+        if (matchedHandoff === undefined) {
             return;
         }
-        // Built-in eval directive: run playground batches without an agent turn.
-        // Only when the bot is addressed — a watched channel post is dispatched
-        // whatever it says, and may open with `eval` while talking to someone else.
-        const evalCommandsEnabled = args.evalCommandsEnabled !== false && (kind === "app_mention" || kind === "direct_message");
-        const evalDirective = evalCommandsEnabled && args.host.evals !== undefined
-            ? ((_8 = parseSlackEvalDirective(message.text)) !== null && _8 !== void 0 ? _8 : parseSlackEvalDirective(message.markdown))
-            : null;
-        if (evalDirective !== null && args.host.evals !== undefined) {
-            if (membership !== undefined && (yield membership)) {
-                dropExternal();
-                yield retractUnadoptedHandoff();
-                return;
-            }
-            log.info("eval directive", {
-                kind,
+        const adoption = adoptPlaceholder({
+            channelId: matchedHandoff.channelId,
+            threadTs: matchedHandoff.threadTs,
+            ts: matchedHandoff.messageTs,
+            streamed: matchedHandoff.streamed,
+        });
+        if (adoption === "adopted") {
+            adoptedPlaceholder = true;
+            log.info("placeholder adopted from control-plane handoff", {
                 channel: message.channelId,
                 thread_ts: message.threadTs,
-                continuation,
-                event_id: args.eventId,
-                directive: evalDirective.kind,
+                message_ts: matchedHandoff.messageTs,
             });
-            yield handleSlackEvalDirective({
-                directive: evalDirective,
-                evals: args.host.evals,
-                binding,
-            });
-            yield retractUnadoptedHandoff();
             return;
         }
-        let decision;
-        try {
-            decision = yield args.handler(binding, message);
+        if (adoption === "occupied") {
+            // Another delivery owns this thread's slot. Remove only this delivery's
+            // redundant CP post.
+            await retractUnadoptedHandoff();
         }
-        catch (error) {
-            log.error(`${kind} handler failed`, {
-                error: error instanceof Error ? error.message : String(error),
-                channel: message.channelId,
-                thread_ts: message.threadTs,
-                event_id: args.eventId,
-            });
-            if (args.propagateHandlerErrors === true) {
-                if (((_h = mapThrownRequestError(error)) === null || _h === void 0 ? void 0 : _h.retry) !== "transient") {
-                    yield retractUnadoptedHandoff();
-                }
-                throw error;
-            }
-            yield retractUnadoptedHandoff();
+    };
+    const retractAdoptedPlaceholder = async () => {
+        if (!adoptedPlaceholder) {
             return;
         }
-        if (decision === null || decision === undefined) {
-            log.info("inbound skipped (handler returned null)", {
+        adoptedPlaceholder = false;
+        await retractPlaceholderSlot({
+            channelId: message.channelId,
+            threadTs: message.threadTs,
+            botToken: args.credentials?.botToken,
+            log,
+        });
+    };
+    const userId = message.author?.userId ?? "";
+    const teamId = message.teamId;
+    let membership;
+    if (args.blockExternals !== false && message.author?.isBot !== true) {
+        if (teamId === undefined || teamId === "") {
+            log.info("inbound dropped (missing team)", {
                 kind,
                 channel: message.channelId,
                 thread_ts: message.threadTs,
+                user: userId,
                 event_id: args.eventId,
             });
-            yield retractUnadoptedHandoff();
+            await retractUnadoptedHandoff();
             return;
         }
-        // Reply-once / delayed parent: claim channel:ts after the handler accepts.
-        const claimed = yield (_j = args.host.slackNudges) === null || _j === void 0 ? void 0 : _j.tryClaimAsk(message.channelId, message.ts);
-        if (claimed === false) {
-            log.info("inbound ask dedupe drop", {
-                kind,
-                channel: message.channelId,
-                message_ts: message.ts,
-                continuation,
-                event_id: args.eventId,
-            });
+        membership = isExternalSlackSender({
+            botToken: args.credentials?.botToken,
+            slackTeamId: teamId,
+            userId,
+        });
+    }
+    const dropExternal = () => {
+        log.info("inbound dropped (external sender)", {
+            kind,
+            channel: message.channelId,
+            thread_ts: message.threadTs,
+            user: userId,
+            team: teamId,
+            event_id: args.eventId,
+        });
+    };
+    const { probeKey: continuation, sendPatch } = slackSessionContinuation(args.continuation, message.channelId, message.threadTs);
+    const loadThread = !isSlackImChannel(message.channelId);
+    const hosted = args.propagateHandlerErrors === true;
+    const existsP = args.hasContinuationSession === undefined || (!loadThread && !hosted)
+        ? undefined
+        : args.hasContinuationSession(continuation);
+    // Whole-message stop: cancel active turn + clear nudges (Benny parity).
+    if (isWholeMessageStop(message.text) || isWholeMessageStop(message.markdown)) {
+        if (membership !== undefined && (await membership)) {
+            dropExternal();
+            await retractUnadoptedHandoff();
             return;
         }
-        yield adoptMatchedHandoff();
-        const painted = args.ack === undefined
-            ? undefined
-            : paintTurnStart({
-                botToken: (_k = args.credentials) === null || _k === void 0 ? void 0 : _k.botToken,
+        log.info("stop directive", {
+            kind,
+            channel: message.channelId,
+            thread_ts: message.threadTs,
+            continuation,
+            event_id: args.eventId,
+        });
+        await args.host.slackNudges?.clear(continuation);
+        const interrupted = args.interruptContinuation === undefined
+            ? false
+            : await args.interruptContinuation(continuation);
+        try {
+            await binding.thread.startTyping(interrupted ? "Stopped." : "Nothing to stop.");
+        }
+        catch {
+            // best-effort status
+        }
+        await retractUnadoptedHandoff();
+        return;
+    }
+    // Built-in eval directive: run playground batches without an agent turn.
+    // Only when the bot is addressed — a watched channel post is dispatched
+    // whatever it says, and may open with `eval` while talking to someone else.
+    const evalCommandsEnabled = args.evalCommandsEnabled !== false && (kind === "app_mention" || kind === "direct_message");
+    const evalDirective = evalCommandsEnabled && args.host.evals !== undefined
+        ? (parseSlackEvalDirective(message.text) ?? parseSlackEvalDirective(message.markdown))
+        : null;
+    if (evalDirective !== null && args.host.evals !== undefined) {
+        if (membership !== undefined && (await membership)) {
+            dropExternal();
+            await retractUnadoptedHandoff();
+            return;
+        }
+        log.info("eval directive", {
+            kind,
+            channel: message.channelId,
+            thread_ts: message.threadTs,
+            continuation,
+            event_id: args.eventId,
+            directive: evalDirective.kind,
+        });
+        await handleSlackEvalDirective({
+            directive: evalDirective,
+            evals: args.host.evals,
+            binding,
+        });
+        await retractUnadoptedHandoff();
+        return;
+    }
+    let decision;
+    try {
+        decision = await args.handler(binding, message);
+    }
+    catch (error) {
+        log.error(`${kind} handler failed`, {
+            error: error instanceof Error ? error.message : String(error),
+            channel: message.channelId,
+            thread_ts: message.threadTs,
+            event_id: args.eventId,
+        });
+        if (args.propagateHandlerErrors === true) {
+            if (mapThrownRequestError(error)?.retry !== "transient") {
+                await retractUnadoptedHandoff();
+            }
+            throw error;
+        }
+        await retractUnadoptedHandoff();
+        return;
+    }
+    if (decision === null || decision === undefined) {
+        log.info("inbound skipped (handler returned null)", {
+            kind,
+            channel: message.channelId,
+            thread_ts: message.threadTs,
+            event_id: args.eventId,
+        });
+        await retractUnadoptedHandoff();
+        return;
+    }
+    // Reply-once / delayed parent: claim channel:ts after the handler accepts.
+    const claimed = await args.host.slackNudges?.tryClaimAsk(message.channelId, message.ts);
+    if (claimed === false) {
+        log.info("inbound ask dedupe drop", {
+            kind,
+            channel: message.channelId,
+            message_ts: message.ts,
+            continuation,
+            event_id: args.eventId,
+        });
+        return;
+    }
+    await adoptMatchedHandoff();
+    const painted = args.ack === undefined
+        ? undefined
+        : paintTurnStart({
+            botToken: args.credentials?.botToken,
+            channelId: message.channelId,
+            threadTs: message.threadTs,
+            ack: args.ack,
+            log,
+        });
+    if (message.ts === message.threadTs && !isSlackImChannel(message.channelId)) {
+        void maybeSetThreadTitle({
+            botToken: args.credentials?.botToken,
+            channelId: message.channelId,
+            threadTs: message.threadTs,
+            title: firstLineTitle(message.markdown),
+            log,
+        });
+    }
+    // A control-plane placeholder is turn scaffolding, not thread history: the
+    // guest posts the reply over that exact ts, so hydrating it would feed the
+    // model its own "still working" line as an already-sent reply.
+    const excludeThreadTimestamps = [
+        message.ts,
+        ...(handoffInThread === undefined ? [] : [handoffInThread.messageTs]),
+        ...(decision.excludeThreadTimestamps ?? []),
+    ];
+    const mergeMessages = [triggeringMergeMessage(message)];
+    const continuationExists = existsP === undefined ? false : await existsP;
+    const hasSession = loadThread && continuationExists;
+    const afterTs = loadThread && hasSession && args.getContinuationLastBotMessageTs !== undefined
+        ? await args.getContinuationLastBotMessageTs(continuation)
+        : undefined;
+    const selfIdentity = resolveSlackSelfIdentity(args.credentials?.botToken);
+    const senderTask = resolveSlackSender({
+        botToken: args.credentials?.botToken,
+        author: message.author,
+    });
+    // Channel mentions: cold <slack_thread>, warm <slack_thread_delta>.
+    const threadTask = !loadThread
+        ? Promise.resolve(EMPTY_SLACK_THREAD_CONTEXT)
+        : hasSession
+            ? loadSlackThreadDelta({
+                botToken: args.credentials?.botToken,
                 channelId: message.channelId,
                 threadTs: message.threadTs,
-                ack: args.ack,
+                ...(afterTs === undefined ? {} : { afterTs }),
+                excludeTs: excludeThreadTimestamps,
+                mergeMessages,
+                log,
+            })
+            : loadSlackThreadContext({
+                botToken: args.credentials?.botToken,
+                channelId: message.channelId,
+                threadTs: message.threadTs,
+                excludeTs: excludeThreadTimestamps,
+                mergeMessages,
                 log,
             });
-        if (message.ts === message.threadTs && !isSlackImChannel(message.channelId)) {
-            void maybeSetThreadTitle({
-                botToken: (_l = args.credentials) === null || _l === void 0 ? void 0 : _l.botToken,
+    const [thread, external] = await Promise.all([threadTask, membership ?? Promise.resolve(false)]);
+    if (external === true) {
+        dropExternal();
+        if (painted !== undefined) {
+            await painted;
+            await retractTurnStart({
+                botToken: args.credentials?.botToken,
                 channelId: message.channelId,
                 threadTs: message.threadTs,
-                title: firstLineTitle(message.markdown),
+                ack: args.ack ?? "",
                 log,
             });
         }
-        // A control-plane placeholder is turn scaffolding, not thread history: the
-        // guest posts the reply over that exact ts, so hydrating it would feed the
-        // model its own "still working" line as an already-sent reply.
-        const excludeThreadTimestamps = [
-            message.ts,
-            ...(handoffInThread === undefined ? [] : [handoffInThread.messageTs]),
-            ...((_9 = decision.excludeThreadTimestamps) !== null && _9 !== void 0 ? _9 : []),
-        ];
-        const mergeMessages = [triggeringMergeMessage(message)];
-        const continuationExists = existsP === undefined ? false : yield existsP;
-        const hasSession = loadThread && continuationExists;
-        const afterTs = loadThread && hasSession && args.getContinuationLastBotMessageTs !== undefined
-            ? yield args.getContinuationLastBotMessageTs(continuation)
-            : undefined;
-        const selfIdentity = resolveSlackSelfIdentity((_m = args.credentials) === null || _m === void 0 ? void 0 : _m.botToken);
-        const senderName = resolveSlackSenderName({
-            botToken: (_o = args.credentials) === null || _o === void 0 ? void 0 : _o.botToken,
-            author: message.author,
+        await args.host.slackNudges?.releaseAsk(message.channelId, message.ts);
+        await retractAdoptedPlaceholder();
+        return;
+    }
+    const threadContext = thread.block;
+    const threadFileCount = thread.files.length;
+    const media = await slackTurnMedia({
+        message,
+        threadFiles: thread.files,
+        decision,
+        botToken: args.credentials?.botToken,
+        log,
+    });
+    if ((message.files !== undefined && message.files.length > 0) || threadFileCount > 0) {
+        log.info("slack attachments prepared", {
+            kind,
+            channel: message.channelId,
+            thread_ts: message.threadTs,
+            thread_files: threadFileCount,
+            images: media.images?.length ?? 0,
+            workspace_files: Object.keys(media.workspaceFiles ?? {}).length,
+            event_id: args.eventId,
         });
-        // Channel mentions: cold <slack_thread>, warm <slack_thread_delta>.
-        const threadTask = !loadThread
-            ? Promise.resolve(EMPTY_SLACK_THREAD_CONTEXT)
-            : hasSession
-                ? loadSlackThreadDelta(Object.assign(Object.assign({ botToken: (_p = args.credentials) === null || _p === void 0 ? void 0 : _p.botToken, channelId: message.channelId, threadTs: message.threadTs }, (afterTs === undefined ? {} : { afterTs })), { excludeTs: excludeThreadTimestamps, mergeMessages,
-                    log }))
-                : loadSlackThreadContext({
-                    botToken: (_q = args.credentials) === null || _q === void 0 ? void 0 : _q.botToken,
-                    channelId: message.channelId,
-                    threadTs: message.threadTs,
-                    excludeTs: excludeThreadTimestamps,
-                    mergeMessages,
-                    log,
-                });
-        const [thread, external] = yield Promise.all([threadTask, membership !== null && membership !== void 0 ? membership : Promise.resolve(false)]);
-        if (external === true) {
-            dropExternal();
-            if (painted !== undefined) {
-                yield painted;
-                yield retractTurnStart({
-                    botToken: (_r = args.credentials) === null || _r === void 0 ? void 0 : _r.botToken,
-                    channelId: message.channelId,
-                    threadTs: message.threadTs,
-                    ack: (_10 = args.ack) !== null && _10 !== void 0 ? _10 : "",
-                    log,
-                });
-            }
-            yield (_s = args.host.slackNudges) === null || _s === void 0 ? void 0 : _s.releaseAsk(message.channelId, message.ts);
-            yield retractAdoptedPlaceholder();
-            return;
-        }
-        const threadContext = thread.block;
-        const threadFileCount = thread.files.length;
-        const media = yield slackTurnMedia({
-            message,
-            threadFiles: thread.files,
-            decision,
-            botToken: (_t = args.credentials) === null || _t === void 0 ? void 0 : _t.botToken,
-            log,
+    }
+    if (threadContext !== undefined) {
+        log.info(hasSession ? "thread delta loaded" : "thread context loaded", {
+            kind,
+            channel: message.channelId,
+            thread_ts: message.threadTs,
+            chars: threadContext.length,
+            event_id: args.eventId,
+            ...(afterTs === undefined ? {} : { after_ts: afterTs }),
         });
-        if ((message.files !== undefined && message.files.length > 0) || threadFileCount > 0) {
-            log.info("slack attachments prepared", {
+    }
+    const [self, sender] = await Promise.all([selfIdentity, senderTask]);
+    const prompt = [
+        formatSlackContextBlock({
+            userId: message.author?.userId ?? "",
+            channelId: message.channelId,
+            threadTs: message.threadTs,
+            userName: sender.name,
+            userTz: sender.tz,
+            ...(message.author?.isBot === true ? { userIsBot: true } : {}),
+            ...(message.author?.botId === undefined ? {} : { userBotId: message.author.botId }),
+            ...(message.teamId === undefined ? {} : { teamId: message.teamId }),
+            ...(self === undefined ? {} : { selfUserId: self.userId }),
+            ...(self?.name === undefined ? {} : { selfName: self.name }),
+        }),
+        ...(threadContext === undefined ? [] : [threadContext]),
+        ...(decision.context ?? []),
+        "",
+        media.userText,
+    ]
+        .filter(part => part.length > 0)
+        .join("\n");
+    const paintedStart = painted !== undefined;
+    const placeholderLine = args.placeholder;
+    const hasPlaceholder = placeholderLine !== undefined && kind !== "channel_post";
+    const hostedFollowup = hosted && hasPlaceholder && (message.ts !== message.threadTs || continuationExists);
+    // Adopted slots already exist in Slack; skip a second post. Cold hosted
+    // without a handoff still defers to `turn.started`.
+    const placeholder = !adoptedPlaceholder && hasPlaceholder && (!hosted || hostedFollowup)
+        ? startPlaceholder({
+            line: placeholderLine,
+            botToken: args.credentials?.botToken,
+            channelId: message.channelId,
+            threadTs: message.threadTs,
+            log,
+            recipientUserId: message.author?.userId,
+            recipientTeamId: message.teamId,
+        })
+        : undefined;
+    const posted = adoptedPlaceholder || placeholder !== undefined;
+    const state = emptySlackChannelState({
+        channelId: message.channelId,
+        threadTs: message.threadTs,
+        teamId: message.teamId ?? null,
+        triggeringUserId: message.author?.userId ?? null,
+        startPainted: paintedStart,
+        placeholderPosted: posted,
+    });
+    const sendOptions = {
+        auth: decision.auth,
+        ...sendPatch,
+        admission: "coalesce",
+        coalesceSourceTs: message.ts,
+        state: state,
+        refreshState: slackWakeChannelState({
+            channelId: message.channelId,
+            threadTs: message.threadTs,
+            teamId: message.teamId ?? null,
+            triggeringUserId: message.author?.userId ?? null,
+            startPainted: paintedStart,
+            placeholderPosted: posted,
+        }),
+        title: decision.title ?? `slack:${message.channelId}:${message.threadTs}`,
+        workspaceDir: decision.workspaceDir,
+        workspaceFiles: media.workspaceFiles,
+        images: media.images,
+        cloud: decision.cloud,
+        sdkAgentId: decision.sdkAgentId,
+    };
+    try {
+        const session = await args.send(prompt, sendOptions);
+        if (isDeferredChannelSession(session)) {
+            log.info("session send captured (hosted admission)", {
                 kind,
+                continuation,
                 channel: message.channelId,
                 thread_ts: message.threadTs,
-                thread_files: threadFileCount,
-                images: (_11 = (_u = media.images) === null || _u === void 0 ? void 0 : _u.length) !== null && _11 !== void 0 ? _11 : 0,
-                workspace_files: Object.keys((_12 = media.workspaceFiles) !== null && _12 !== void 0 ? _12 : {}).length,
                 event_id: args.eventId,
             });
+            return;
         }
-        if (threadContext !== undefined) {
-            log.info(hasSession ? "thread delta loaded" : "thread context loaded", Object.assign({ kind, channel: message.channelId, thread_ts: message.threadTs, chars: threadContext.length, event_id: args.eventId }, (afterTs === undefined ? {} : { after_ts: afterTs })));
-        }
-        const [self, userName] = yield Promise.all([selfIdentity, senderName]);
-        const prompt = [
-            formatSlackContextBlock(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({ userId: (_13 = (_v = message.author) === null || _v === void 0 ? void 0 : _v.userId) !== null && _13 !== void 0 ? _13 : "", channelId: message.channelId, threadTs: message.threadTs }, (userName === undefined ? {} : { userName })), (((_w = message.author) === null || _w === void 0 ? void 0 : _w.isBot) === true ? { userIsBot: true } : {})), (((_x = message.author) === null || _x === void 0 ? void 0 : _x.botId) === undefined ? {} : { userBotId: message.author.botId })), (message.teamId === undefined ? {} : { teamId: message.teamId })), (self === undefined ? {} : { selfUserId: self.userId })), ((self === null || self === void 0 ? void 0 : self.name) === undefined ? {} : { selfName: self.name }))),
-            ...(threadContext === undefined ? [] : [threadContext]),
-            ...((_14 = decision.context) !== null && _14 !== void 0 ? _14 : []),
-            "",
-            media.userText,
-        ]
-            .filter(part => part.length > 0)
-            .join("\n");
-        const paintedStart = painted !== undefined;
-        const placeholderLine = args.placeholder;
-        const hasPlaceholder = placeholderLine !== undefined && kind !== "channel_post";
-        const hostedFollowup = hosted && hasPlaceholder && (message.ts !== message.threadTs || continuationExists);
-        // Adopted slots already exist in Slack; skip a second post. Cold hosted
-        // without a handoff still defers to `turn.started`.
-        const placeholder = !adoptedPlaceholder && hasPlaceholder && (!hosted || hostedFollowup)
-            ? startPlaceholder({
-                line: placeholderLine,
-                botToken: (_y = args.credentials) === null || _y === void 0 ? void 0 : _y.botToken,
-                channelId: message.channelId,
-                threadTs: message.threadTs,
-                log,
-                recipientUserId: (_z = message.author) === null || _z === void 0 ? void 0 : _z.userId,
-                recipientTeamId: message.teamId,
-            })
-            : undefined;
-        const posted = adoptedPlaceholder || placeholder !== undefined;
-        const state = emptySlackChannelState({
-            channelId: message.channelId,
-            threadTs: message.threadTs,
-            teamId: (_15 = message.teamId) !== null && _15 !== void 0 ? _15 : null,
-            triggeringUserId: (_16 = (_0 = message.author) === null || _0 === void 0 ? void 0 : _0.userId) !== null && _16 !== void 0 ? _16 : null,
-            startPainted: paintedStart,
-            placeholderPosted: posted,
+        log.info(session.coalesced === true ? "session coalesced" : "session start", {
+            kind,
+            session: session.id,
+            is_new: session.isNew,
+            coalesced: session.coalesced === true,
+            continuation,
+            channel: message.channelId,
+            thread_ts: message.threadTs,
+            event_id: args.eventId,
         });
-        const sendOptions = Object.assign(Object.assign({ auth: decision.auth }, sendPatch), { admission: "coalesce", coalesceSourceTs: message.ts, state: state, refreshState: slackWakeChannelState({
-                channelId: message.channelId,
-                threadTs: message.threadTs,
-                teamId: (_17 = message.teamId) !== null && _17 !== void 0 ? _17 : null,
-                triggeringUserId: (_18 = (_1 = message.author) === null || _1 === void 0 ? void 0 : _1.userId) !== null && _18 !== void 0 ? _18 : null,
-                startPainted: paintedStart,
-                placeholderPosted: posted,
-            }), title: (_19 = decision.title) !== null && _19 !== void 0 ? _19 : `slack:${message.channelId}:${message.threadTs}`, workspaceDir: decision.workspaceDir, workspaceFiles: media.workspaceFiles, images: media.images, cloud: decision.cloud, sdkAgentId: decision.sdkAgentId });
-        try {
-            const session = yield args.send(prompt, sendOptions);
-            if (isDeferredChannelSession(session)) {
-                log.info("session send captured (hosted admission)", {
-                    kind,
-                    continuation,
-                    channel: message.channelId,
-                    thread_ts: message.threadTs,
-                    event_id: args.eventId,
-                });
-                return;
-            }
-            log.info(session.coalesced === true ? "session coalesced" : "session start", {
+        // Coalesce admits leave the active turn running: the follow-up is queued
+        // for the carrier to inject at the next tool boundary, and anything it
+        // does not reach in time drains into the boundary turn instead.
+        // Keep the placeholder; a new DM ts cannot overlay the carrier turn.
+        if (session.coalesced === true) {
+            log.info("session busy; coalescing follow-up", {
                 kind,
-                session: session.id,
-                is_new: session.isNew,
-                coalesced: session.coalesced === true,
-                continuation,
                 channel: message.channelId,
                 thread_ts: message.threadTs,
+                continuation,
                 event_id: args.eventId,
             });
-            // Coalesce admits leave the active turn running: the follow-up is queued
-            // for the carrier to inject at the next tool boundary, and anything it
-            // does not reach in time drains into the boundary turn instead.
-            // Keep the placeholder; a new DM ts cannot overlay the carrier turn.
-            if (session.coalesced === true) {
-                log.info("session busy; coalescing follow-up", {
-                    kind,
-                    channel: message.channelId,
-                    thread_ts: message.threadTs,
-                    continuation,
-                    event_id: args.eventId,
-                });
-                if (!steeringEnabled()) {
-                    try {
-                        yield (_2 = args.host.slackNudges) === null || _2 === void 0 ? void 0 : _2.append({
-                            continuationKey: continuation,
-                            sourceTs: message.ts,
-                            text: media.userText,
-                            author: (_3 = message.author) === null || _3 === void 0 ? void 0 : _3.userName,
-                        });
-                    }
-                    catch (nudgeError) {
-                        log.warn("nudge append failed", {
-                            error: nudgeError instanceof Error ? nudgeError.message : String(nudgeError),
-                            continuation,
-                            event_id: args.eventId,
-                        });
-                    }
-                }
+            if (!steeringEnabled()) {
                 try {
-                    if (args.followUpStatus !== false) {
-                        yield binding.thread.startTyping(FOLLOWUP_TYPING);
-                    }
+                    await args.host.slackNudges?.append({
+                        continuationKey: continuation,
+                        sourceTs: message.ts,
+                        text: media.userText,
+                        author: message.author?.userName,
+                    });
                 }
-                catch (typingError) {
-                    log.error(`follow-up typing failed: ${typingError instanceof Error ? typingError.message : String(typingError)}`, {
-                        channel: message.channelId,
-                        thread_ts: message.threadTs,
+                catch (nudgeError) {
+                    log.warn("nudge append failed", {
+                        error: nudgeError instanceof Error ? nudgeError.message : String(nudgeError),
+                        continuation,
                         event_id: args.eventId,
                     });
                 }
             }
-        }
-        catch (error) {
-            yield (_4 = args.host.slackNudges) === null || _4 === void 0 ? void 0 : _4.releaseAsk(message.channelId, message.ts);
-            if (placeholder !== undefined) {
-                yield placeholder.retract();
+            try {
+                if (args.followUpStatus !== false) {
+                    await binding.thread.startTyping(FOLLOWUP_TYPING);
+                }
             }
-            yield retractAdoptedPlaceholder();
-            if (painted !== undefined) {
-                yield painted;
-                yield retractTurnStart({
-                    botToken: (_5 = args.credentials) === null || _5 === void 0 ? void 0 : _5.botToken,
-                    channelId: message.channelId,
-                    threadTs: message.threadTs,
-                    ack: (_20 = args.ack) !== null && _20 !== void 0 ? _20 : "",
-                    log,
+            catch (typingError) {
+                log.error(`follow-up typing failed: ${typingError instanceof Error ? typingError.message : String(typingError)}`, {
+                    channel: message.channelId,
+                    thread_ts: message.threadTs,
+                    event_id: args.eventId,
                 });
             }
-            log.error(`${kind} delivery failed: ${error instanceof Error ? error.message : String(error)}`, {
-                channel: message.channelId,
-                thread_ts: message.threadTs,
-                continuation,
-                event_id: args.eventId,
+        }
+    }
+    catch (error) {
+        await args.host.slackNudges?.releaseAsk(message.channelId, message.ts);
+        if (placeholder !== undefined) {
+            await placeholder.retract();
+        }
+        await retractAdoptedPlaceholder();
+        if (painted !== undefined) {
+            await painted;
+            await retractTurnStart({
+                botToken: args.credentials?.botToken,
+                channelId: message.channelId,
+                threadTs: message.threadTs,
+                ack: args.ack ?? "",
+                log,
             });
         }
-        finally {
-            if (placeholder !== undefined) {
-                yield placeholder.done;
-            }
+        log.error(`${kind} delivery failed: ${error instanceof Error ? error.message : String(error)}`, {
+            channel: message.channelId,
+            thread_ts: message.threadTs,
+            continuation,
+            event_id: args.eventId,
+        });
+    }
+    finally {
+        if (placeholder !== undefined) {
+            await placeholder.done;
         }
-    });
+    }
 }
 /**
  * Parse an Events API body (or Socket Mode `events_api` payload) and dispatch
@@ -584,18 +657,15 @@ export function dispatchInboundMessage(args) {
  * present. Returns true when a handler was scheduled.
  */
 export function dispatchInboundFromEventBody(body, deps) {
-    var _a, _b, _c, _d;
-    var _e, _f, _g, _h, _j;
-    const log = (_e = deps.log) !== null && _e !== void 0 ? _e : defaultSlackLog;
+    const log = deps.log ?? defaultSlackLog;
     let eventId;
     const retractUnscheduledHandoff = () => {
-        var _a, _b;
-        const placeholder = (_a = deps.platformHandoff) === null || _a === void 0 ? void 0 : _a.slackPlaceholder;
+        const placeholder = deps.platformHandoff?.slackPlaceholder;
         if (placeholder === undefined) {
             return;
         }
         deps.waitUntil(retractPlaceholderMessage({
-            botToken: (_b = deps.credentials) === null || _b === void 0 ? void 0 : _b.botToken,
+            botToken: deps.credentials?.botToken,
             channelId: placeholder.channelId,
             ts: placeholder.messageTs,
             streamed: placeholder.streamed,
@@ -622,10 +692,10 @@ export function dispatchInboundFromEventBody(body, deps) {
             retractUnscheduledHandoff();
             return false;
         }
-        if (((_a = mention.author) === null || _a === void 0 ? void 0 : _a.isBot) === true) {
+        if (mention.author?.isBot === true) {
             // Parse only admits bot-authored mentions when a gate exists, so the
             // fallback is defensive.
-            const verdict = (_f = (_b = deps.botMentionGate) === null || _b === void 0 ? void 0 : _b.evaluate(mention)) !== null && _f !== void 0 ? _f : {
+            const verdict = deps.botMentionGate?.evaluate(mention) ?? {
                 allow: false,
                 reason: "bot mentions not enabled",
             };
@@ -634,7 +704,7 @@ export function dispatchInboundFromEventBody(body, deps) {
                     event_id: eventId,
                     channel: mention.channelId,
                     thread_ts: mention.threadTs,
-                    from_bot: (_g = mention.author.botId) !== null && _g !== void 0 ? _g : mention.author.userId,
+                    from_bot: mention.author.botId ?? mention.author.userId,
                     reason: verdict.reason,
                 });
                 retractUnscheduledHandoff();
@@ -684,7 +754,7 @@ export function dispatchInboundFromEventBody(body, deps) {
     }
     const home = parseAppHomeOpened(body);
     if (home !== null) {
-        const prompts = (_h = deps.suggestedPrompts) !== null && _h !== void 0 ? _h : [];
+        const prompts = deps.suggestedPrompts ?? [];
         log.info("app home opened", {
             channel: home.channelId,
             tab: home.tab,
@@ -693,7 +763,7 @@ export function dispatchInboundFromEventBody(body, deps) {
         });
         if (home.tab === "messages" && prompts.length > 0) {
             deps.waitUntil(maybeSetSuggestedPrompts({
-                botToken: (_c = deps.credentials) === null || _c === void 0 ? void 0 : _c.botToken,
+                botToken: deps.credentials?.botToken,
                 channelId: home.channelId,
                 prompts,
                 title: deps.suggestedPromptsTitle,
@@ -704,7 +774,7 @@ export function dispatchInboundFromEventBody(body, deps) {
     }
     const assistantThread = parseAssistantThreadStarted(body);
     if (assistantThread !== null) {
-        const prompts = (_j = deps.suggestedPrompts) !== null && _j !== void 0 ? _j : [];
+        const prompts = deps.suggestedPrompts ?? [];
         log.info("assistant thread started", {
             channel: assistantThread.channelId,
             thread_ts: assistantThread.threadTs,
@@ -713,7 +783,7 @@ export function dispatchInboundFromEventBody(body, deps) {
         });
         if (prompts.length > 0) {
             deps.waitUntil(maybeSetSuggestedPrompts({
-                botToken: (_d = deps.credentials) === null || _d === void 0 ? void 0 : _d.botToken,
+                botToken: deps.credentials?.botToken,
                 channelId: assistantThread.channelId,
                 threadTs: assistantThread.threadTs,
                 prompts,
@@ -734,7 +804,10 @@ export function dispatchInboundFromEventBody(body, deps) {
             return deps.channelWatch.handle(channelEvent, eventId);
         }
     }
-    log.debug("inbound ignored (unhandled event shape)", Object.assign(Object.assign({}, describeSlackEventShape(body)), { event_id: eventId }));
+    log.debug("inbound ignored (unhandled event shape)", {
+        ...describeSlackEventShape(body),
+        event_id: eventId,
+    });
     retractUnscheduledHandoff();
     return false;
 }