@cursor/bdk 0.2.9 → 0.2.11

package/dist/channels/slack/defaults.js

@@ -1,26 +1,6 @@
 /**
  * Default inbound handlers and stream-event sinks for the Slack channel.
  */
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
 import { markHostedFirstVisibleReply, noteHostedVisibleReplyError, } from "../../internal/hosted-execution-latency.js";
 import { buildAgenticEvents } from "./agentic-delivery.js";
 import { postMessage, setThreadStatus } from "./api.js";
@@ -40,16 +20,15 @@ import { rememberPendingToolCall, takeToolChipLine } from "./tool-chip.js";
 const SLACK_TURN_FAILURE_FALLBACK = "I hit an error while handling your request. Please try again or rephrase.";
 const SLACK_TURN_FAILURE_MAX_CHARS = 400;
 export function resolveSlackRespondTo(policy) {
-    return (policy === null || policy === void 0 ? void 0 : policy.respondTo) === "author" ? "author" : "thread";
+    return policy?.respondTo === "author" ? "author" : "thread";
 }
 /** Defaults to true when omitted. */
 export function resolveSlackBlockExternals(policy) {
-    return (policy === null || policy === void 0 ? void 0 : policy.blockExternals) !== false;
+    return policy?.blockExternals !== false;
 }
 /** Scrubbed turn.failed body for Slack (secrets / paths / URLs stripped). */
 export function formatSlackTurnFailureMessage(raw) {
-    var _a;
-    const scrubbed = scrubSlackErrorDetail((_a = raw === null || raw === void 0 ? void 0 : raw.trim()) !== null && _a !== void 0 ? _a : "");
+    const scrubbed = scrubSlackErrorDetail(raw?.trim() ?? "");
     if (scrubbed === "") {
         return SLACK_TURN_FAILURE_FALLBACK;
     }
@@ -88,11 +67,11 @@ function resolveLoadingMessages(loadingMessages) {
 export function createDefaultOnInbound(loadingMessages, policy) {
     const rotating = resolveLoadingMessages(loadingMessages);
     const respondTo = resolveSlackRespondTo(policy);
-    return (ctx, message) => __awaiter(this, void 0, void 0, function* () {
-        yield ctx.thread.startTyping("Thinking…", rotating);
+    return async (ctx, message) => {
+        await ctx.thread.startTyping("Thinking…", rotating);
         const auth = defaultSlackAuth(message, ctx, { respondTo });
         return auth === null ? null : { auth };
-    });
+    };
 }
 /**
  * Default watched-channel-post handler (optional custom loading rotation).
@@ -102,14 +81,14 @@ export function createDefaultOnInbound(loadingMessages, policy) {
 export function createDefaultOnChannelPost(loadingMessages, policy) {
     const rotating = resolveLoadingMessages(loadingMessages);
     const respondTo = resolveSlackRespondTo(policy);
-    return (ctx, message) => __awaiter(this, void 0, void 0, function* () {
-        yield ctx.thread.startTyping("Thinking…", rotating);
+    return async (ctx, message) => {
+        await ctx.thread.startTyping("Thinking…", rotating);
         const auth = defaultSlackAuth(message, ctx, {
             engagement: "channel_post",
             respondTo,
         });
         return auth === null ? null : { auth };
-    });
+    };
 }
 export const defaultOnAppMention = createDefaultOnInbound();
 export const defaultOnDirectMessage = createDefaultOnInbound();
@@ -124,7 +103,6 @@ export const defaultOnChannelPost = createDefaultOnChannelPost();
  * `buildToolApprovalEvents` or set `toolApprovals: true` on `slackChannel`.
  */
 export function buildDefaultEvents(options = {}) {
-    var _a, _b;
     const credentials = options.credentials;
     const reply = resolveSlackReply({
         reply: options.reply,
@@ -144,23 +122,22 @@ export function buildDefaultEvents(options = {}) {
         });
     }
     const streaming = reply.mode === "stream";
-    const suggestedPrompts = (_a = options.suggestedPrompts) !== null && _a !== void 0 ? _a : [];
+    const suggestedPrompts = options.suggestedPrompts ?? [];
     const suggestedPromptsTitle = options.suggestedPromptsTitle;
     const loadingMessages = reply.status.idle;
-    const botToken = credentials === null || credentials === void 0 ? void 0 : credentials.botToken;
-    const getLog = (_b = options.getLog) !== null && _b !== void 0 ? _b : (() => defaultSlackLog);
+    const botToken = credentials?.botToken;
+    const getLog = options.getLog ?? (() => defaultSlackLog);
     const strategy = createStreamDeliveryStrategy({ botToken, getLog });
     const progress = createProgressDelivery({ botToken, getLog });
     const streamLive = (state) => streaming && !state.streamingUnavailable;
     const streamTarget = (channel) => {
-        var _a;
-        const channelId = (_a = channel.state.streamChannelId) !== null && _a !== void 0 ? _a : channel.state.channelId;
+        const channelId = channel.state.streamChannelId ?? channel.state.channelId;
         if (channelId === null || channelId === "" || channel.state.threadTs === null) {
             return null;
         }
         return channelId;
     };
-    const sendCards = (args) => __awaiter(this, void 0, void 0, function* () {
+    const sendCards = async (args) => {
         if (!streamLive(args.channel.state)) {
             return false;
         }
@@ -168,24 +145,21 @@ export function buildDefaultEvents(options = {}) {
         if (channelId === null) {
             return false;
         }
-        return strategy.appendChunks(Object.assign(Object.assign({}, args), { channelId }));
-    });
+        return strategy.appendChunks({ ...args, channelId });
+    };
     const reasoning = reply.reasoningCard === false
         ? null
-        : createReasoningCard(reply.reasoningCard, (_a) => {
-            var { chunk } = _a, rest = __rest(_a, ["chunk"]);
-            return sendCards(Object.assign(Object.assign({}, rest), { chunks: [chunk] }));
-        });
+        : createReasoningCard(reply.reasoningCard, ({ chunk, ...rest }) => sendCards({ ...rest, chunks: [chunk] }));
     const toolCards = reply.toolCards === false ? null : createToolCards(reply.toolCards, reply.toolLabel);
-    const completeReasoning = (channel, sessionId) => __awaiter(this, void 0, void 0, function* () {
-        if (reasoning === null || reasoning === void 0 ? void 0 : reasoning.inProgress(channel)) {
-            yield reasoning.flush({ channel, sessionId, status: "complete" });
+    const completeReasoning = async (channel, sessionId) => {
+        if (reasoning?.inProgress(channel)) {
+            await reasoning.flush({ channel, sessionId, status: "complete" });
         }
-    });
+    };
     /** Subagent events carry `parentCallId`; cards and the reply are the parent's. */
     const nested = (event) => event.data.parentCallId !== undefined;
-    const clearWorkingStatus = (channelId, threadTs) => __awaiter(this, void 0, void 0, function* () {
-        const result = yield setThreadStatus({
+    const clearWorkingStatus = async (channelId, threadTs) => {
+        const result = await setThreadStatus({
             botToken,
             channelId,
             threadTs,
@@ -198,14 +172,14 @@ export function buildDefaultEvents(options = {}) {
                 thread_ts: threadTs,
             });
         }
-    });
-    const finishProgress = (args) => __awaiter(this, void 0, void 0, function* () {
+    };
+    const finishProgress = async (args) => {
         const log = getLog();
         const state = args.channel.state;
         if (state.channelId === null || state.threadTs === null || args.text === "") {
             return false;
         }
-        if (yield progress.replace({ channel: args.channel, text: args.text })) {
+        if (await progress.replace({ channel: args.channel, text: args.text })) {
             log.info("reply delivered via progress update", {
                 channel: state.channelId,
                 thread_ts: state.threadTs,
@@ -218,9 +192,9 @@ export function buildDefaultEvents(options = {}) {
             });
             return true;
         }
-        yield progress.clear({ channel: args.channel });
+        await progress.clear({ channel: args.channel });
         try {
-            const posted = yield postMessage({
+            const posted = await postMessage({
                 botToken,
                 channel: state.channelId,
                 text: args.text,
@@ -250,15 +224,14 @@ export function buildDefaultEvents(options = {}) {
             noteHostedVisibleReplyError({ deliverySurface: "slack" });
             return false;
         }
-    });
+    };
     /**
      * Deliver assistant text to the bound Slack thread. Used by a stop-reason
      * `message.completed` and by `turn.completed` when the last assistant
      * block was `finishReason: "tool_call"` (answer then `tag_artifact`,
      * etc.) so the playground result still reaches Slack.
      */
-    const deliverReplyText = (args) => __awaiter(this, void 0, void 0, function* () {
-        var _a, _b;
+    const deliverReplyText = async (args) => {
         const state = args.channel.state;
         if (state.channelId === null || state.threadTs === null || args.text === "") {
             return false;
@@ -269,23 +242,23 @@ export function buildDefaultEvents(options = {}) {
             const streamTs = state.streamTs;
             if (streamTs !== null && streamTs !== "") {
                 if (streamLive(state)) {
-                    yield strategy.finalize({
+                    await strategy.finalize({
                         channel: args.channel,
-                        channelId: (_a = state.streamChannelId) !== null && _a !== void 0 ? _a : state.channelId,
+                        channelId: state.streamChannelId ?? state.channelId,
                         text: args.text,
                         sessionId: args.sessionId,
                     });
                 }
                 else {
-                    yield strategy.cleanupOrphan({ channel: args.channel });
+                    await strategy.cleanupOrphan({ channel: args.channel });
                 }
             }
             return true;
         }
         if (streamLive(state)) {
-            const { delivered } = yield strategy.finalize({
+            const { delivered } = await strategy.finalize({
                 channel: args.channel,
-                channelId: (_b = state.streamChannelId) !== null && _b !== void 0 ? _b : state.channelId,
+                channelId: state.streamChannelId ?? state.channelId,
                 text: args.text,
                 sessionId: args.sessionId,
             });
@@ -294,8 +267,8 @@ export function buildDefaultEvents(options = {}) {
             }
         }
         return finishProgress(args);
-    });
-    const paintReplyFooter = (args) => __awaiter(this, void 0, void 0, function* () {
+    };
+    const paintReplyFooter = async (args) => {
         const state = args.channel.state;
         const ts = state.lastBotMessageTs;
         const text = state.lastPostedText;
@@ -308,7 +281,7 @@ export function buildDefaultEvents(options = {}) {
             streamHasCards(state)) {
             return;
         }
-        const result = yield paintSlackFooter({
+        const result = await paintSlackFooter({
             footer: reply.footer,
             ctx: {
                 sessionId: args.sessionId,
@@ -328,303 +301,291 @@ export function buildDefaultEvents(options = {}) {
                 ts,
             });
         }
-    });
+    };
     return {
-        "turn.started"(event, channel) {
-            return __awaiter(this, void 0, void 0, function* () {
-                const log = getLog();
-                yield progress.clear({ channel });
-                channel.state.pendingToolCallMessage = null;
-                channel.state.lastReasoningTypingAtMs = null;
-                channel.state.lastReasoningTypingStatus = null;
-                channel.state.streamTs = null;
-                channel.state.streamChannelId = null;
-                channel.state.streamFull = false;
-                // A stream failure downgrades the rest of its own turn, not the thread.
-                channel.state.streamingUnavailable = false;
-                channel.state.streamAppendedChunks = 0;
-                channel.state.lastPostedText = null;
-                channel.state.streamBlockText = null;
-                channel.state.turnStartedAtMs = Date.now();
-                channel.state.reasoningCard = undefined;
-                channel.state.toolCardCounts = {};
-                // Keep lastBotMessageTs across turns — warm delta watermark.
-                channel.state.approvalMessageByCallId = {};
-                const state = channel.state;
-                if (state.channelId === null || state.threadTs === null) {
-                    return;
-                }
-                log.info("turn.started", {
-                    session: event.sessionId,
-                    turn: event.turnId,
-                    channel: state.channelId,
-                    thread_ts: state.threadTs,
-                });
-                yield setThreadStatus({
-                    botToken,
-                    channelId: state.channelId,
-                    threadTs: state.threadTs,
-                    status: "Working…",
-                    loadingMessages,
-                });
+        async "turn.started"(event, channel) {
+            const log = getLog();
+            await progress.clear({ channel });
+            channel.state.pendingToolCallMessage = null;
+            channel.state.lastReasoningTypingAtMs = null;
+            channel.state.lastReasoningTypingStatus = null;
+            channel.state.streamTs = null;
+            channel.state.streamChannelId = null;
+            channel.state.streamFull = false;
+            // A stream failure downgrades the rest of its own turn, not the thread.
+            channel.state.streamingUnavailable = false;
+            channel.state.streamAppendedChunks = 0;
+            channel.state.lastPostedText = null;
+            channel.state.streamBlockText = null;
+            channel.state.turnStartedAtMs = Date.now();
+            channel.state.reasoningCard = undefined;
+            channel.state.toolCardCounts = {};
+            // Keep lastBotMessageTs across turns — warm delta watermark.
+            channel.state.approvalMessageByCallId = {};
+            const state = channel.state;
+            if (state.channelId === null || state.threadTs === null) {
+                return;
+            }
+            log.info("turn.started", {
+                session: event.sessionId,
+                turn: event.turnId,
+                channel: state.channelId,
+                thread_ts: state.threadTs,
+            });
+            await setThreadStatus({
+                botToken,
+                channelId: state.channelId,
+                threadTs: state.threadTs,
+                status: "Working…",
+                loadingMessages,
             });
         },
-        "message.appended"(event, channel) {
-            return __awaiter(this, void 0, void 0, function* () {
-                // Nested (subagent) text is not the reply.
-                if (nested(event) || !streamLive(channel.state)) {
-                    return;
-                }
-                const channelId = streamTarget(channel);
-                if (channelId === null) {
-                    return;
-                }
-                yield completeReasoning(channel, event.sessionId);
-                yield strategy.append({
+        async "message.appended"(event, channel) {
+            // Nested (subagent) text is not the reply.
+            if (nested(event) || !streamLive(channel.state)) {
+                return;
+            }
+            const channelId = streamTarget(channel);
+            if (channelId === null) {
+                return;
+            }
+            await completeReasoning(channel, event.sessionId);
+            await strategy.append({
+                channel,
+                channelId,
+                text: event.data.text,
+                sessionId: event.sessionId,
+            });
+        },
+        async "reasoning.appended"(event, channel) {
+            if (!nested(event)) {
+                await reasoning?.append({
                     channel,
-                    channelId,
-                    text: event.data.text,
                     sessionId: event.sessionId,
+                    text: event.data.text,
                 });
+            }
+            // The chip is hidden while a stream is open.
+            if (!reply.status.reasoning || channel.state.streamTs !== null) {
+                return;
+            }
+            const now = Date.now();
+            const status = nextReasoningChip(channel.state, event.data.text, now);
+            if (status === undefined) {
+                return;
+            }
+            if (channel.state.channelId === null || channel.state.threadTs === null) {
+                return;
+            }
+            // One entry: Slack cycles `loading_messages` every couple of seconds,
+            // so padding an informative line with the rotation makes the chip
+            // flip between the reasoning and filler until the next update.
+            const painted = await setThreadStatus({
+                botToken,
+                channelId: channel.state.channelId,
+                threadTs: channel.state.threadTs,
+                status,
+                loadingMessages: [status],
             });
+            if (painted.ok) {
+                commitReasoningChip(channel.state, status, now);
+            }
         },
-        "reasoning.appended"(event, channel) {
-            return __awaiter(this, void 0, void 0, function* () {
-                if (!nested(event)) {
-                    yield reasoning === null || reasoning === void 0 ? void 0 : reasoning.append({
-                        channel,
-                        sessionId: event.sessionId,
-                        text: event.data.text,
-                    });
-                }
-                // The chip is hidden while a stream is open.
-                if (!reply.status.reasoning || channel.state.streamTs !== null) {
-                    return;
-                }
-                const now = Date.now();
-                const status = nextReasoningChip(channel.state, event.data.text, now);
-                if (status === undefined) {
-                    return;
-                }
-                if (channel.state.channelId === null || channel.state.threadTs === null) {
-                    return;
-                }
-                // One entry: Slack cycles `loading_messages` every couple of seconds,
-                // so padding an informative line with the rotation makes the chip
-                // flip between the reasoning and filler until the next update.
-                const painted = yield setThreadStatus({
-                    botToken,
-                    channelId: channel.state.channelId,
-                    threadTs: channel.state.threadTs,
-                    status,
-                    loadingMessages: [status],
-                });
-                if (painted.ok) {
-                    commitReasoningChip(channel.state, status, now);
-                }
+        async "reasoning.completed"(event, channel) {
+            if (reasoning === null || nested(event)) {
+                return;
+            }
+            reasoning.endBlock(channel);
+            await reasoning.flush({
+                channel,
+                sessionId: event.sessionId,
+                status: "in_progress",
             });
         },
-        "reasoning.completed"(event, channel) {
-            return __awaiter(this, void 0, void 0, function* () {
-                if (reasoning === null || nested(event)) {
-                    return;
-                }
-                reasoning.endBlock(channel);
-                yield reasoning.flush({
+        async "actions.requested"(event, channel) {
+            const calls = event.data.calls;
+            const statusText = takeToolChipLine(channel.state, reply.status.tools, calls);
+            if (toolCards !== null && strategy.inlineToolSteps && !nested(event)) {
+                // Card order: the thinking that led to these tools goes first.
+                await reasoning?.flush({
                     channel,
                     sessionId: event.sessionId,
                     status: "in_progress",
                 });
-            });
-        },
-        "actions.requested"(event, channel) {
-            return __awaiter(this, void 0, void 0, function* () {
-                const calls = event.data.calls;
-                const statusText = takeToolChipLine(channel.state, reply.status.tools, calls);
-                if (toolCards !== null && strategy.inlineToolSteps && !nested(event)) {
-                    // Card order: the thinking that led to these tools goes first.
-                    yield reasoning === null || reasoning === void 0 ? void 0 : reasoning.flush({
-                        channel,
-                        sessionId: event.sessionId,
-                        status: "in_progress",
-                    });
-                    const streamed = yield sendCards({
-                        channel,
-                        sessionId: event.sessionId,
-                        chunks: toolCards.forCalls(channel.state, calls),
-                    });
-                    // An open stream hides the chip; skip the status write.
-                    if (streamed) {
-                        return;
-                    }
-                }
-                if (statusText === undefined) {
-                    return;
-                }
-                if (channel.state.channelId === null || channel.state.threadTs === null) {
-                    return;
-                }
-                // Hold the tool line steady; see reasoning.appended.
-                yield setThreadStatus({
-                    botToken,
-                    channelId: channel.state.channelId,
-                    threadTs: channel.state.threadTs,
-                    status: statusText,
-                    loadingMessages: [statusText],
+                const streamed = await sendCards({
+                    channel,
+                    sessionId: event.sessionId,
+                    chunks: toolCards.forCalls(channel.state, calls),
                 });
-                if (toolCards !== null &&
-                    channel.state.streamingUnavailable === true &&
-                    (channel.state.streamTs === null || channel.state.streamTs === "")) {
-                    yield progress.upsert({ channel, text: statusText });
+                // An open stream hides the chip; skip the status write.
+                if (streamed) {
+                    return;
                 }
+            }
+            if (statusText === undefined) {
+                return;
+            }
+            if (channel.state.channelId === null || channel.state.threadTs === null) {
+                return;
+            }
+            // Hold the tool line steady; see reasoning.appended.
+            await setThreadStatus({
+                botToken,
+                channelId: channel.state.channelId,
+                threadTs: channel.state.threadTs,
+                status: statusText,
+                loadingMessages: [statusText],
             });
+            if (toolCards !== null &&
+                channel.state.streamingUnavailable === true &&
+                (channel.state.streamTs === null || channel.state.streamTs === "")) {
+                await progress.upsert({ channel, text: statusText });
+            }
         },
-        "action.result"(event, channel) {
-            return __awaiter(this, void 0, void 0, function* () {
-                const streamTs = channel.state.streamTs;
-                if (toolCards === null ||
-                    !strategy.inlineToolSteps ||
-                    nested(event) ||
-                    streamTs === null ||
-                    streamTs === "") {
-                    return;
-                }
-                yield sendCards({
-                    channel,
-                    sessionId: event.sessionId,
-                    chunks: [
-                        toolCards.forResult(channel.state, {
-                            callId: event.data.callId,
-                            toolName: event.data.toolName,
-                            output: event.data.output,
-                            isError: event.data.isError,
-                        }),
-                    ],
-                });
+        async "action.result"(event, channel) {
+            const streamTs = channel.state.streamTs;
+            if (toolCards === null ||
+                !strategy.inlineToolSteps ||
+                nested(event) ||
+                streamTs === null ||
+                streamTs === "") {
+                return;
+            }
+            await sendCards({
+                channel,
+                sessionId: event.sessionId,
+                chunks: [
+                    toolCards.forResult(channel.state, {
+                        callId: event.data.callId,
+                        toolName: event.data.toolName,
+                        output: event.data.output,
+                        isError: event.data.isError,
+                    }),
+                ],
             });
         },
-        "message.completed"(event, channel) {
-            return __awaiter(this, void 0, void 0, function* () {
-                if (nested(event)) {
-                    return;
-                }
-                rememberPendingToolCall(channel.state, event.data.finishReason, event.data.text);
-                if (event.data.finishReason === "tool_call") {
-                    // The harness restarts its cumulative text after a tool call, so the
-                    // next block appends in full instead of diffing against this one.
-                    channel.state.streamBlockText = null;
-                    return;
-                }
-                const state = channel.state;
-                if (state.channelId === null || state.threadTs === null) {
-                    return;
-                }
-                yield completeReasoning(channel, event.sessionId);
-                // Empty final text: still close any open stream / clear the skeleton
-                // and clear typing.
-                if (event.data.text === "") {
-                    yield strategy.finalizeEmpty({ channel });
-                    yield progress.clear({ channel });
-                    yield clearWorkingStatus(state.channelId, state.threadTs);
-                    return;
-                }
-                yield deliverReplyText({
-                    channel,
-                    text: event.data.text,
-                    sessionId: event.sessionId,
-                });
-                yield clearWorkingStatus(state.channelId, state.threadTs);
+        async "message.completed"(event, channel) {
+            if (nested(event)) {
+                return;
+            }
+            rememberPendingToolCall(channel.state, event.data.finishReason, event.data.text);
+            if (event.data.finishReason === "tool_call") {
+                // The harness restarts its cumulative text after a tool call, so the
+                // next block appends in full instead of diffing against this one.
+                channel.state.streamBlockText = null;
+                return;
+            }
+            const state = channel.state;
+            if (state.channelId === null || state.threadTs === null) {
+                return;
+            }
+            await completeReasoning(channel, event.sessionId);
+            // Empty final text: still close any open stream / clear the skeleton
+            // and clear typing.
+            if (event.data.text === "") {
+                await strategy.finalizeEmpty({ channel });
+                await progress.clear({ channel });
+                await clearWorkingStatus(state.channelId, state.threadTs);
+                return;
+            }
+            await deliverReplyText({
+                channel,
+                text: event.data.text,
+                sessionId: event.sessionId,
             });
+            await clearWorkingStatus(state.channelId, state.threadTs);
         },
-        "turn.completed"(event, channel, ctx) {
-            return __awaiter(this, void 0, void 0, function* () {
-                const log = getLog();
-                log.info("turn.completed", {
-                    session: event.sessionId,
-                    turn: event.turnId,
-                    channel: channel.state.channelId,
-                    thread_ts: channel.state.threadTs,
-                });
-                // Mid-turn `tool_call` text is held as status, not posted. If the
-                // turn ends without a later `finishReason: "stop"` block, the
-                // playground still has `result` (last assistant text) and Slack
-                // would otherwise stay silent.
-                const result = event.data.result;
-                const unpublished = typeof result === "string" && result !== "" && result !== channel.state.lastPostedText;
-                yield completeReasoning(channel, event.sessionId);
-                if (unpublished) {
-                    yield deliverReplyText({
-                        channel,
-                        text: result,
-                        sessionId: event.sessionId,
-                    });
-                }
-                // Always close leftovers. deliverReplyText may fall through to
-                // postMessage when streaming is unavailable and leave streamTs open.
-                yield strategy.cleanupOrphan({ channel });
-                yield progress.clear({ channel });
-                yield paintReplyFooter({
+        async "turn.completed"(event, channel, ctx) {
+            const log = getLog();
+            log.info("turn.completed", {
+                session: event.sessionId,
+                turn: event.turnId,
+                channel: channel.state.channelId,
+                thread_ts: channel.state.threadTs,
+            });
+            // Mid-turn `tool_call` text is held as status, not posted. If the
+            // turn ends without a later `finishReason: "stop"` block, the
+            // playground still has `result` (last assistant text) and Slack
+            // would otherwise stay silent.
+            const result = event.data.result;
+            const unpublished = typeof result === "string" && result !== "" && result !== channel.state.lastPostedText;
+            await completeReasoning(channel, event.sessionId);
+            if (unpublished) {
+                await deliverReplyText({
                     channel,
+                    text: result,
                     sessionId: event.sessionId,
-                    status: "completed",
-                    host: ctx.host,
                 });
-                // Always drop the assistant chip. message.completed already clears
-                // after a normal reply, but a tool-call-only finish (or a missed
-                // final assistant message) never hits that path — leaving
-                // "Working…" stuck until Slack expires it.
-                if (channel.state.channelId !== null && channel.state.threadTs !== null) {
-                    yield clearWorkingStatus(channel.state.channelId, channel.state.threadTs);
-                }
-                if (suggestedPrompts.length === 0 ||
-                    channel.state.channelId === null ||
-                    channel.state.threadTs === null) {
-                    return;
-                }
-                yield maybeSetSuggestedPrompts(Object.assign(Object.assign({ botToken, channelId: channel.state.channelId, threadTs: channel.state.threadTs, prompts: suggestedPrompts }, (suggestedPromptsTitle === undefined ? {} : { title: suggestedPromptsTitle })), { log }));
+            }
+            // Always close leftovers. deliverReplyText may fall through to
+            // postMessage when streaming is unavailable and leave streamTs open.
+            await strategy.cleanupOrphan({ channel });
+            await progress.clear({ channel });
+            await paintReplyFooter({
+                channel,
+                sessionId: event.sessionId,
+                status: "completed",
+                host: ctx.host,
+            });
+            // Always drop the assistant chip. message.completed already clears
+            // after a normal reply, but a tool-call-only finish (or a missed
+            // final assistant message) never hits that path — leaving
+            // "Working…" stuck until Slack expires it.
+            if (channel.state.channelId !== null && channel.state.threadTs !== null) {
+                await clearWorkingStatus(channel.state.channelId, channel.state.threadTs);
+            }
+            if (suggestedPrompts.length === 0 ||
+                channel.state.channelId === null ||
+                channel.state.threadTs === null) {
+                return;
+            }
+            await maybeSetSuggestedPrompts({
+                botToken,
+                channelId: channel.state.channelId,
+                threadTs: channel.state.threadTs,
+                prompts: suggestedPrompts,
+                ...(suggestedPromptsTitle === undefined ? {} : { title: suggestedPromptsTitle }),
+                log,
             });
         },
-        "turn.failed"(event, channel, ctx) {
-            return __awaiter(this, void 0, void 0, function* () {
-                var _a;
-                const log = getLog();
-                const state = channel.state;
-                log.error("turn.failed", {
-                    session: event.sessionId,
-                    turn: event.turnId,
-                    error: event.data.message,
-                    channel: state.channelId,
-                    thread_ts: state.threadTs,
-                });
-                if (state.channelId === null || state.threadTs === null) {
-                    return;
-                }
-                const errorText = formatSlackTurnFailureMessage(event.data.message);
-                let delivered = false;
-                if (streamLive(state)) {
-                    yield completeReasoning(channel, event.sessionId);
-                    ({ delivered } = yield strategy.fail({
-                        channel,
-                        channelId: (_a = state.streamChannelId) !== null && _a !== void 0 ? _a : state.channelId,
-                        errorText,
-                        sessionId: event.sessionId,
-                    }));
-                }
-                if (!delivered) {
-                    yield finishProgress({
-                        channel,
-                        text: errorText,
-                        sessionId: event.sessionId,
-                    });
-                }
-                yield paintReplyFooter({
+        async "turn.failed"(event, channel, ctx) {
+            const log = getLog();
+            const state = channel.state;
+            log.error("turn.failed", {
+                session: event.sessionId,
+                turn: event.turnId,
+                error: event.data.message,
+                channel: state.channelId,
+                thread_ts: state.threadTs,
+            });
+            if (state.channelId === null || state.threadTs === null) {
+                return;
+            }
+            const errorText = formatSlackTurnFailureMessage(event.data.message);
+            let delivered = false;
+            if (streamLive(state)) {
+                await completeReasoning(channel, event.sessionId);
+                ({ delivered } = await strategy.fail({
                     channel,
+                    channelId: state.streamChannelId ?? state.channelId,
+                    errorText,
+                    sessionId: event.sessionId,
+                }));
+            }
+            if (!delivered) {
+                await finishProgress({
+                    channel,
+                    text: errorText,
                     sessionId: event.sessionId,
-                    status: "failed",
-                    host: ctx.host,
                 });
-                yield clearWorkingStatus(state.channelId, state.threadTs);
+            }
+            await paintReplyFooter({
+                channel,
+                sessionId: event.sessionId,
+                status: "failed",
+                host: ctx.host,
             });
+            await clearWorkingStatus(state.channelId, state.threadTs);
         },
     };
 }