experimental-ash 0.10.2 → 0.10.3

package/dist/src/public/channels/slack/interactions.js

@@ -0,0 +1,311 @@
+/**
+ * Slack `block_actions` + `view_submission` wire handling.
+ *
+ * The route handler reads the form-encoded body, hands it here, and we:
+ *
+ * 1. Decode `block_actions` payloads into a typed shape the channel can
+ *    work with — actions, channel/thread metadata, the clicker, and the
+ *    full original block list for answered-card updates.
+ * 2. Open the freeform-answer modal inline when the click was a "Type
+ *    your answer" button (Slack's `trigger_id` is only valid for ~3s,
+ *    so this can't run under `waitUntil`).
+ * 3. Resolve `view_submission` payloads (freeform modal submissions)
+ *    back into parked HITL requests via `send`.
+ *
+ * Anything we don't consume flows through to the user-supplied
+ * `onInteraction` callback. Always returns `Response("ok")` — followup
+ * work runs under `waitUntil` so the webhook ACK is immediate.
+ */
+import { createLogger } from "#internal/logging.js";
+import { buildSlackApiHandle, resolveSlackBotToken } from "#public/channels/slack/api.js";
+import { buildAnsweredBlocks, buildFreeformModalView, deriveHitlResponse, freeformRequestIdFromActionId, HITL_FREEFORM_MODAL_ACTION_ID, HITL_FREEFORM_MODAL_BLOCK_ID, HITL_FREEFORM_MODAL_CALLBACK_ID, isFreeformAction, isHitlAction, } from "#public/channels/slack/hitl.js";
+const log = createLogger("slack.interactions");
+/**
+ * Decodes a Slack `block_actions` payload into a {@link ParsedBlockActionsPayload}.
+ * Returns `null` for payloads that don't carry the channel/thread
+ * metadata the handler needs.
+ */
+export function parseBlockActionsPayload(body) {
+    const actions = body.actions;
+    if (!Array.isArray(actions))
+        return null;
+    const channel = body.channel?.id;
+    const message = body.message;
+    const threadTs = message?.thread_ts ?? message?.ts;
+    if (!channel || !threadTs)
+        return null;
+    const team = body.team;
+    const user = body.user;
+    const teamId = team?.id ?? user?.team_id;
+    const userId = typeof user?.id === "string" ? user.id : undefined;
+    // `message.ts` is the ts of the message that hosts the clicked component.
+    // It differs from `threadTs` whenever the bot's message is a thread reply,
+    // and is required for `chat.update` on the clicked message.
+    const messageTs = typeof message?.ts === "string" ? message.ts : undefined;
+    const messageBlocks = Array.isArray(message?.blocks) ? message.blocks : [];
+    return {
+        actions: actions.map((a) => ({
+            actionId: String(a.action_id ?? ""),
+            value: a.value != null ? String(a.value) : undefined,
+            blockId: a.block_id != null ? String(a.block_id) : undefined,
+            selectedOptionValue: extractSelectedOptionValue(a),
+            messageTs,
+            label: extractActionLabel(a),
+        })),
+        channelId: channel,
+        threadTs,
+        teamId,
+        userId,
+        messageBlocks,
+    };
+}
+function extractSelectedOptionValue(action) {
+    const selected = action.selected_option;
+    return typeof selected?.value === "string" ? selected.value : undefined;
+}
+function extractActionLabel(action) {
+    const selected = action.selected_option;
+    const fromSelected = selected?.text?.text;
+    if (typeof fromSelected === "string" && fromSelected.length > 0)
+        return fromSelected;
+    const buttonText = action.text?.text;
+    if (typeof buttonText === "string" && buttonText.length > 0)
+        return buttonText;
+    return undefined;
+}
+function findPromptBlock(blocks) {
+    for (const block of blocks) {
+        if (typeof block === "object" &&
+            block !== null &&
+            block.type === "section") {
+            return block;
+        }
+    }
+    return undefined;
+}
+function readPromptTextFromBlocks(blocks) {
+    const prompt = findPromptBlock(blocks);
+    const text = prompt?.text?.text;
+    return typeof text === "string" && text.length > 0 ? text : undefined;
+}
+/**
+ * Entry point for Slack's form-encoded interactivity endpoint. Routes
+ * `view_submission` payloads to the freeform-answer flow, intercepts
+ * "Type your answer" button clicks to open a modal, resolves
+ * framework HITL clicks against the parked session, and forwards
+ * anything else to `config.onInteraction`.
+ */
+export async function handleInteractionPost(rawBody, ctx, deps) {
+    const ack = new Response("ok", { status: 200 });
+    const params = new URLSearchParams(rawBody);
+    const payloadStr = params.get("payload");
+    if (!payloadStr)
+        return ack;
+    let payload;
+    try {
+        payload = JSON.parse(payloadStr);
+    }
+    catch {
+        log.warn("failed to parse Slack interaction payload");
+        return ack;
+    }
+    if (payload?.type === "view_submission") {
+        return handleViewSubmission(payload, ctx, deps);
+    }
+    const interaction = parseBlockActionsPayload(payload);
+    if (!interaction)
+        return ack;
+    const freeformAction = interaction.actions.find((a) => isFreeformAction(a.actionId));
+    if (freeformAction) {
+        await openFreeformModal({ payload, interaction, freeformAction, deps });
+        return ack;
+    }
+    const continuationToken = `slack:${interaction.channelId}:${interaction.threadTs}`;
+    const inputResponses = interaction.actions
+        .map(deriveHitlResponse)
+        .filter((r) => r !== null);
+    if (inputResponses.length > 0) {
+        ctx.waitUntil(ctx
+            .send({ inputResponses }, {
+            auth: null,
+            continuationToken,
+            state: {
+                serializedThread: null,
+                teamId: interaction.teamId ?? null,
+                triggeringUserId: interaction.userId ?? null,
+            },
+        })
+            .catch((error) => {
+            log.error("HITL interaction delivery failed", { error });
+        }));
+        ctx.waitUntil(updateAnsweredHitlCard(interaction, deps).catch((error) => {
+            log.error("HITL answered-card update failed", { error });
+        }));
+    }
+    const onInteraction = deps.config.onInteraction;
+    if (onInteraction) {
+        const customActions = interaction.actions.filter((a) => !isHitlAction(a.actionId));
+        if (customActions.length > 0) {
+            const chatModule = await deps.loadChatModule();
+            const thread = new chatModule.ThreadImpl({
+                adapterName: "slack",
+                channelId: interaction.channelId,
+                id: `slack:${interaction.channelId}:${interaction.threadTs}`,
+                isDM: false,
+            });
+            const slackCtx = {
+                thread,
+                slack: buildSlackApiHandle(thread, deps.config.credentials?.botToken, interaction.teamId),
+            };
+            for (const action of customActions) {
+                ctx.waitUntil(Promise.resolve(onInteraction(action, slackCtx)).catch((error) => {
+                    log.error("custom interaction handler failed", { error });
+                }));
+            }
+        }
+    }
+    return ack;
+}
+async function openFreeformModal(input) {
+    const triggerId = input.payload.trigger_id;
+    if (typeof triggerId !== "string" || triggerId.length === 0) {
+        log.warn("freeform button click missing trigger_id — cannot open modal");
+        return;
+    }
+    const requestId = freeformRequestIdFromActionId(input.freeformAction.actionId) ?? input.freeformAction.value;
+    if (!requestId) {
+        log.warn("freeform button click missing requestId");
+        return;
+    }
+    const messageTs = input.freeformAction.messageTs;
+    if (!messageTs) {
+        log.warn("freeform button click missing messageTs");
+        return;
+    }
+    const metadata = {
+        continuationToken: `slack:${input.interaction.channelId}:${input.interaction.threadTs}`,
+        channelId: input.interaction.channelId,
+        threadTs: input.interaction.threadTs,
+        messageTs,
+        requestId,
+    };
+    const promptText = readPromptTextFromBlocks(input.interaction.messageBlocks);
+    const view = buildFreeformModalView({ metadata, prompt: promptText });
+    const token = await resolveSlackBotToken(input.deps.config.credentials?.botToken);
+    const response = await fetch("https://slack.com/api/views.open", {
+        method: "POST",
+        headers: {
+            authorization: `Bearer ${token}`,
+            "content-type": "application/json; charset=utf-8",
+        },
+        body: JSON.stringify({ trigger_id: triggerId, view }),
+    });
+    if (!response.ok) {
+        log.error("Slack views.open returned non-2xx", { status: response.status });
+    }
+}
+async function handleViewSubmission(payload, ctx, deps) {
+    const ack = new Response("ok", { status: 200 });
+    const view = payload.view;
+    if (view?.callback_id !== HITL_FREEFORM_MODAL_CALLBACK_ID)
+        return ack;
+    let metadata;
+    try {
+        metadata = JSON.parse(view.private_metadata ?? "");
+    }
+    catch {
+        log.warn("freeform view_submission carries invalid private_metadata");
+        return ack;
+    }
+    if (!metadata.continuationToken ||
+        !metadata.requestId ||
+        !metadata.messageTs ||
+        !metadata.channelId ||
+        !metadata.threadTs) {
+        return ack;
+    }
+    const raw = view.state?.values?.[HITL_FREEFORM_MODAL_BLOCK_ID]?.[HITL_FREEFORM_MODAL_ACTION_ID]?.value;
+    const text = typeof raw === "string" ? raw : "";
+    if (text.length === 0)
+        return ack;
+    const user = payload.user;
+    const triggeringUserId = typeof user?.id === "string" ? user.id : null;
+    const teamId = typeof user?.team_id === "string" ? user.team_id : null;
+    ctx.waitUntil(ctx
+        .send({ inputResponses: [{ requestId: metadata.requestId, text }] }, {
+        auth: null,
+        continuationToken: metadata.continuationToken,
+        state: {
+            serializedThread: null,
+            teamId,
+            triggeringUserId,
+        },
+    })
+        .catch((error) => {
+        log.error("freeform answer delivery failed", { error });
+    }));
+    ctx.waitUntil(updateAnsweredFreeformCard({
+        channelId: metadata.channelId,
+        messageTs: metadata.messageTs,
+        answerLabel: text,
+        userId: triggeringUserId ?? undefined,
+        deps,
+    }).catch((error) => {
+        log.error("freeform answered-card update failed", { error });
+    }));
+    return ack;
+}
+async function updateAnsweredHitlCard(interaction, deps) {
+    const hitlAction = interaction.actions.find((a) => isHitlAction(a.actionId));
+    if (!hitlAction || !hitlAction.messageTs)
+        return;
+    const answerLabel = hitlAction.label ?? hitlAction.selectedOptionValue ?? hitlAction.value;
+    if (!answerLabel)
+        return;
+    const blocks = buildAnsweredBlocks({
+        promptBlock: findPromptBlock(interaction.messageBlocks),
+        answerLabel,
+        userId: interaction.userId,
+    });
+    const token = await resolveSlackBotToken(deps.config.credentials?.botToken);
+    const response = await fetch("https://slack.com/api/chat.update", {
+        method: "POST",
+        headers: {
+            authorization: `Bearer ${token}`,
+            "content-type": "application/json; charset=utf-8",
+        },
+        body: JSON.stringify({
+            channel: interaction.channelId,
+            ts: hitlAction.messageTs,
+            blocks,
+            text: `Answered: ${answerLabel}`,
+        }),
+    });
+    if (!response.ok) {
+        throw new Error(`Slack chat.update returned HTTP ${response.status}`);
+    }
+}
+async function updateAnsweredFreeformCard(input) {
+    const blocks = buildAnsweredBlocks({
+        promptBlock: undefined,
+        answerLabel: input.answerLabel,
+        userId: input.userId,
+    });
+    const token = await resolveSlackBotToken(input.deps.config.credentials?.botToken);
+    const response = await fetch("https://slack.com/api/chat.update", {
+        method: "POST",
+        headers: {
+            authorization: `Bearer ${token}`,
+            "content-type": "application/json; charset=utf-8",
+        },
+        body: JSON.stringify({
+            channel: input.channelId,
+            ts: input.messageTs,
+            blocks,
+            text: `Answered: ${input.answerLabel}`,
+        }),
+    });
+    if (!response.ok) {
+        throw new Error(`Slack chat.update returned HTTP ${response.status}`);
+    }
+}

package/dist/src/public/channels/slack/limits.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Slack API string-length guards.
+ *
+ * Slack rejects payloads where a string exceeds its surface-specific
+ * limit (typing indicator, Block Kit `plain_text` fields, modal titles,
+ * etc.). The chat SDK does not enforce these for us — anything that
+ * overruns surfaces as a `chat.postMessage` / `assistant.threads.setStatus`
+ * / `views.open` HTTP error. These helpers cap strings before they cross
+ * the wire so a single long tool name or option label cannot fail the
+ * whole event handler.
+ */
+/**
+ * Typing indicator (`assistant.threads.setStatus`) caps at roughly 100
+ * characters; we use 50 to match the pre-existing UX (statuses longer
+ * than a glance are hard to read in the chat UI anyway).
+ */
+export declare const SLACK_TYPING_STATUS_MAX_LENGTH = 50;
+/**
+ * Block Kit `plain_text` fields used in `static_select` / `radio_buttons`
+ * options and button labels are capped at 75 characters by Slack.
+ */
+export declare const SLACK_BLOCK_KIT_PLAIN_TEXT_MAX_LENGTH = 75;
+/**
+ * `views.open` modal title is capped at 24 characters.
+ */
+export declare const SLACK_MODAL_TITLE_MAX_LENGTH = 24;
+/**
+ * Normalizes a typing status: trims, collapses runs of whitespace into a
+ * single space, then truncates to {@link SLACK_TYPING_STATUS_MAX_LENGTH}
+ * with a trailing ellipsis when needed.
+ */
+export declare function truncateTypingStatus(status: string): string;
+/**
+ * Caps a Block Kit `plain_text` label/description at the Slack limit
+ * with a trailing ellipsis. Pass `undefined` to short-circuit (option
+ * descriptions are optional).
+ */
+export declare function truncatePlainText(value: string): string;
+export declare function truncatePlainText(value: string | undefined): string | undefined;
+/**
+ * Caps a modal title at the Slack limit with a trailing ellipsis.
+ */
+export declare function truncateModalTitle(value: string): string;

package/dist/src/public/channels/slack/limits.js

@@ -0,0 +1,52 @@
+/**
+ * Slack API string-length guards.
+ *
+ * Slack rejects payloads where a string exceeds its surface-specific
+ * limit (typing indicator, Block Kit `plain_text` fields, modal titles,
+ * etc.). The chat SDK does not enforce these for us — anything that
+ * overruns surfaces as a `chat.postMessage` / `assistant.threads.setStatus`
+ * / `views.open` HTTP error. These helpers cap strings before they cross
+ * the wire so a single long tool name or option label cannot fail the
+ * whole event handler.
+ */
+/**
+ * Typing indicator (`assistant.threads.setStatus`) caps at roughly 100
+ * characters; we use 50 to match the pre-existing UX (statuses longer
+ * than a glance are hard to read in the chat UI anyway).
+ */
+export const SLACK_TYPING_STATUS_MAX_LENGTH = 50;
+/**
+ * Block Kit `plain_text` fields used in `static_select` / `radio_buttons`
+ * options and button labels are capped at 75 characters by Slack.
+ */
+export const SLACK_BLOCK_KIT_PLAIN_TEXT_MAX_LENGTH = 75;
+/**
+ * `views.open` modal title is capped at 24 characters.
+ */
+export const SLACK_MODAL_TITLE_MAX_LENGTH = 24;
+/**
+ * Normalizes a typing status: trims, collapses runs of whitespace into a
+ * single space, then truncates to {@link SLACK_TYPING_STATUS_MAX_LENGTH}
+ * with a trailing ellipsis when needed.
+ */
+export function truncateTypingStatus(status) {
+    const normalized = status.trim().replace(/\s+/gu, " ");
+    return truncateWithEllipsis(normalized, SLACK_TYPING_STATUS_MAX_LENGTH);
+}
+export function truncatePlainText(value) {
+    if (value === undefined)
+        return undefined;
+    return truncateWithEllipsis(value, SLACK_BLOCK_KIT_PLAIN_TEXT_MAX_LENGTH);
+}
+/**
+ * Caps a modal title at the Slack limit with a trailing ellipsis.
+ */
+export function truncateModalTitle(value) {
+    return truncateWithEllipsis(value, SLACK_MODAL_TITLE_MAX_LENGTH);
+}
+function truncateWithEllipsis(value, maxLength) {
+    if (value.length <= maxLength)
+        return value;
+    const sliceLength = Math.max(0, maxLength - 3);
+    return `${value.slice(0, sliceLength).trimEnd()}...`;
+}

package/dist/src/public/channels/slack/slack.d.ts

@@ -1,10 +1,20 @@
 import type { SessionAuthContext } from "#channel/types.js";
 import type { Channel } from "#public/definitions/defineChannel.js";
-import { type SlackChannelCredentials, type SlackChannelState, type SlackStateAdapter } from "#public/channels/slack/slackChannel.js";
+import { type SlackChannelCredentials, type SlackChannelState, type SlackContext, type SlackEventContext, type SlackStateAdapter } from "#public/channels/slack/slackChannel.js";
 export interface SlackOptions {
-    readonly auth?: (message: import("#compiled/chat/index.js").Message) => SessionAuthContext | null;
+    /**
+     * Maps a verified inbound Slack mention to a {@link SessionAuthContext}.
+     * Receives the chat SDK `Message` plus a {@link SlackContext} carrying
+     * the live `thread` and `slack` API handle so policies can read
+     * channel/thread metadata without re-parsing `message.raw`.
+     *
+     * Defaults to a workspace-scoped projection of the Slack actor; return
+     * `null` to silently drop the mention.
+     */
+    readonly auth?: (message: import("#compiled/chat/index.js").Message, ctx: SlackContext) => SessionAuthContext | null;
     readonly credentials?: SlackChannelCredentials;
     readonly botName?: string;
     readonly stateAdapter?: SlackStateAdapter;
 }
 export declare function slack(options?: SlackOptions): Channel<SlackChannelState>;
+export type { SlackEventContext };

package/dist/src/public/channels/slack/slack.js

@@ -1,43 +1,199 @@
+import { createLogger, extractErrorId, formatErrorHint } from "#internal/logging.js";
+import { buildAuthCompletedText, buildAuthEphemeralBlocks, buildAuthRequiredPublicText, formatConnectionDisplayName, } from "#public/channels/slack/connections.js";
+import { truncateTypingStatus } from "#public/channels/slack/limits.js";
 import { slackChannel, } from "#public/channels/slack/slackChannel.js";
-function defaultSlackAuth(message) {
+const log = createLogger("slack.defaults");
+function readTeamId(message) {
+    const raw = message.raw;
+    const teamId = raw?.team_id ?? raw?.team;
+    return typeof teamId === "string" && teamId.length > 0 ? teamId : undefined;
+}
+function defaultSlackAuth(message, ctx) {
     const author = message.author;
     if (!author)
         return null;
+    const teamId = readTeamId(message);
+    const isBot = author.isBot === true;
+    const userId = String(author.userId);
+    const principalId = teamId
+        ? isBot
+            ? `slack:${teamId}:bot:${userId}`
+            : `slack:${teamId}:${userId}`
+        : isBot
+            ? `slack:bot:${userId}`
+            : `slack:${userId}`;
+    const attributes = {
+        author_type: isBot ? "bot" : "user",
+        channel_id: ctx.slack.channelId,
+        thread_ts: ctx.slack.threadTs,
+        user_id: userId,
+    };
+    if (typeof author.userName === "string" && author.userName.length > 0) {
+        attributes.user_name = author.userName;
+    }
+    if (typeof author.fullName === "string" && author.fullName.length > 0) {
+        attributes.full_name = author.fullName;
+    }
+    if (teamId !== undefined) {
+        attributes.team_id = teamId;
+    }
     return {
-        attributes: {},
-        authenticator: "slack",
-        principalId: author.userId,
-        principalType: author.isBot ? "service" : "user",
+        attributes,
+        authenticator: "slack-webhook",
+        issuer: teamId !== undefined ? `slack:${teamId}` : "slack",
+        principalId,
+        principalType: isBot ? "service" : "user",
     };
 }
+/**
+ * Reads the first non-empty line of a model-emitted message. Used to
+ * surface the model's own pre-tool-call narration as the typing
+ * indicator on the next `actions.requested` event.
+ */
+function firstNonEmptyLine(text) {
+    for (const line of text.split(/\r?\n/u)) {
+        const trimmed = line.trim();
+        if (trimmed.length > 0)
+            return trimmed;
+    }
+    return undefined;
+}
 export function slack(options = {}) {
     const resolveAuth = options.auth ?? defaultSlackAuth;
     return slackChannel({
         credentials: options.credentials,
         botName: options.botName,
         stateAdapter: options.stateAdapter,
-        run(_ctx, message) {
-            return { auth: resolveAuth(message) };
+        run(ctx, message) {
+            return { auth: resolveAuth(message, ctx) };
         },
         async onMention(ctx) {
             await ctx.thread.startTyping("Thinking...");
         },
         events: {
             async "turn.started"(_event, ctx) {
+                ctx.state.pendingToolCallMessage = null;
                 await ctx.thread.startTyping("Working...");
             },
             async "actions.requested"(event, ctx) {
+                const buffered = ctx.state.pendingToolCallMessage;
+                ctx.state.pendingToolCallMessage = null;
+                if (buffered) {
+                    await ctx.thread.startTyping(truncateTypingStatus(buffered));
+                    return;
+                }
                 const labels = event.actions.map((a) => (a.kind === "tool-call" ? a.toolName : a.kind));
-                await ctx.thread.startTyping(`Running ${labels.join(", ")}...`);
+                await ctx.thread.startTyping(truncateTypingStatus(`Running ${labels.join(", ")}...`));
             },
             async "message.completed"(event, ctx) {
-                if (event.finishReason === "tool-calls")
+                if (event.finishReason === "tool-calls") {
+                    // Buffer the model's prose so `actions.requested` can surface
+                    // it as the typing indicator. Don't post — there's no
+                    // user-visible answer yet, just narration before a tool call.
+                    ctx.state.pendingToolCallMessage = event.message
+                        ? (firstNonEmptyLine(event.message) ?? null)
+                        : null;
                     return;
+                }
+                ctx.state.pendingToolCallMessage = null;
                 if (event.message)
-                    await ctx.thread.post(event.message);
+                    await ctx.thread.post({ markdown: event.message });
             },
-            async "session.failed"(_event, ctx) {
-                await ctx.thread.post("Something went wrong.");
+            async "turn.failed"(event, ctx) {
+                const hint = formatErrorHint(event);
+                const errorId = extractErrorId(event.details);
+                await ctx.thread.post({
+                    markdown: [
+                        `I hit an error while handling your request${hint}.`,
+                        "",
+                        "Please try again, rephrase, or reach out if it keeps failing.",
+                        ...(errorId ? ["", `_Error id: \`${errorId}\`_`] : []),
+                    ].join("\n"),
+                });
+            },
+            async "session.failed"(event, ctx) {
+                const hint = formatErrorHint(event);
+                const errorId = extractErrorId(event.details);
+                await ctx.thread.post({
+                    markdown: [
+                        `This session couldn't recover from an error${hint}.`,
+                        "",
+                        "Start a new thread to continue — I can't pick this one back up.",
+                        ...(errorId ? ["", `_Error id: \`${errorId}\`_`] : []),
+                    ].join("\n"),
+                });
+            },
+            async "connection.authorization_required"(event, ctx) {
+                const displayName = formatConnectionDisplayName(event.connectionName);
+                const triggeringUserId = ctx.state.triggeringUserId ?? null;
+                const challengeUrl = event.authorization?.url;
+                if (triggeringUserId && challengeUrl) {
+                    try {
+                        await ctx.slack.request("chat.postEphemeral", {
+                            channel: ctx.slack.channelId,
+                            user: triggeringUserId,
+                            thread_ts: ctx.slack.threadTs,
+                            blocks: buildAuthEphemeralBlocks({ displayName, url: challengeUrl }),
+                            text: `Sign in with ${displayName}: ${challengeUrl}`,
+                        });
+                    }
+                    catch (error) {
+                        log.error("Slack auth ephemeral delivery failed", {
+                            connectionName: event.connectionName,
+                            error,
+                        });
+                    }
+                }
+                const publicText = buildAuthRequiredPublicText({
+                    displayName,
+                    hasUser: triggeringUserId !== null,
+                });
+                try {
+                    const sent = await ctx.thread.post({ markdown: publicText });
+                    const sentId = sent && typeof sent === "object" && "id" in sent
+                        ? sent.id
+                        : undefined;
+                    if (typeof sentId === "string") {
+                        ctx.state.pendingAuthMessageTs = {
+                            ...ctx.state.pendingAuthMessageTs,
+                            [event.connectionName]: sentId,
+                        };
+                    }
+                }
+                catch (error) {
+                    log.error("Slack auth public message delivery failed", {
+                        connectionName: event.connectionName,
+                        error,
+                    });
+                }
+            },
+            async "connection.authorization_completed"(event, ctx) {
+                const pending = ctx.state.pendingAuthMessageTs ?? {};
+                const ts = pending[event.connectionName];
+                if (ts === undefined)
+                    return;
+                const displayName = formatConnectionDisplayName(event.connectionName);
+                const text = buildAuthCompletedText({
+                    displayName,
+                    outcome: event.outcome,
+                    reason: event.reason,
+                });
+                try {
+                    await ctx.slack.request("chat.update", {
+                        channel: ctx.slack.channelId,
+                        ts,
+                        text,
+                    });
+                }
+                catch (error) {
+                    log.error("Slack auth status edit failed", {
+                        connectionName: event.connectionName,
+                        error,
+                    });
+                }
+                const next = { ...pending };
+                delete next[event.connectionName];
+                ctx.state.pendingAuthMessageTs = next;
             },
         },
     });