@intentface/latch-channels 0.9.1

package/dist/slack/slackChannel.js

@@ -0,0 +1,650 @@
+import { consumeRun, isChatBusyError, pendingApprovals } from "../render.js";
+import { withTurnLease } from "../kernel.js";
+import { slackApi } from "./api.js";
+import { verifySlackSignature } from "./verify.js";
+import { DM_ROOT, parseSlackChatId, slackChatId } from "./ids.js";
+import { isRenderableUserMessage, normalizeSlackText } from "./normalize.js";
+import { decodeAction, encodeAction } from "./payloads.js";
+import { APPROVE_ACTION, DENY_ACTION, approvalBlocksV2, approvalResolvedBlocks, connectBlocks, signInCard, } from "./blocks.js";
+import { renderSlackStream } from "./stream.js";
+const ok = () => new Response(null, { status: 200 });
+// Claim TTLs. Dedupe keys are never released — they expire.
+const EVT_TTL = 6 * 3600_000; // Slack retries within the hour; 6h is margin
+const MSG_TTL = 6 * 3600_000;
+const ACT_TTL = 15 * 60_000;
+const NOTE_TTL = 7 * 24 * 3600_000;
+const GENERIC_ERROR = ":warning: Something went wrong running the agent — the details are in Latch.";
+const BUSY_NOTICE = "Still working on the previous message here — send that again when I've answered.";
+const MID_TURN_NOTICE = "The agent is mid-turn here — try again in a moment.";
+function newId() {
+    return globalThis.crypto?.randomUUID?.() ?? `m_${Date.now()}_${Math.round(Math.random() * 1e9)}`;
+}
+/** thread_ts for posting into a chat — the `_dm` chat posts un-threaded. */
+const threadTsOf = (root) => (root === DM_ROOT ? undefined : root);
+export function slackChannel(config) {
+    const api = slackApi(config.botToken, config.apiOptions);
+    const resolveSigningSecret = async () => typeof config.signingSecret === "function" ? config.signingSecret() : config.signingSecret;
+    const defer = (p) => {
+        const guarded = p.catch((e) => console.error("[slack] deferred worker failed:", e));
+        if (config.waitUntil)
+            config.waitUntil(guarded);
+        return guarded;
+    };
+    /** Session-surface status; a no-op outside the bot's DM channel. */
+    async function setSession(channel, root, status) {
+        if (!channel.startsWith("D"))
+            return;
+        const threadTs = threadTsOf(root);
+        await api
+            .sessionsSetStatus({
+            channel_id: channel,
+            status,
+            ...(threadTs ? { thread_ts: threadTs } : {}),
+        })
+            .catch(() => {
+            /* plain DMs aren't sessions; status is best-effort */
+        });
+    }
+    // ── Turn rendering (shared by messages, resumes, replays) ─────────────────
+    async function renderTurn(res, ctx) {
+        const threadTs = threadTsOf(ctx.root) ?? ctx.anchorTs;
+        const result = await renderSlackStream(consumeRun(res), {
+            api,
+            channel: ctx.channel,
+            ...(threadTs ? { threadTs } : {}),
+            recipientTeamId: config.teamId,
+            recipientUserId: ctx.userId,
+            shouldStop: () => config.threads.stoppedSince(ctx.chatId, ctx.turnStartedAt),
+            ...(ctx.resumedToolName ? { resumedToolName: ctx.resumedToolName } : {}),
+            ...(config.onStreamMode
+                ? {
+                    // Return the promise — the renderer awaits it so the persistence
+                    // write is inside the turn the host's waitUntil tracks.
+                    onStreamMode: (info) => config.onStreamMode?.({ chatId: ctx.chatId, ...info }),
+                }
+                : {}),
+            // The legacy free-text status box ("is thinking…"). Assistant/DM
+            // surfaces only, and it needs a thread — best-effort by construction
+            // (the api call swallows its own errors).
+            ...(threadTs
+                ? {
+                    setStatus: (text) => api.setStatus({ channel_id: ctx.channel, thread_ts: threadTs, status: text }),
+                }
+                : {}),
+        });
+        if (result.stopped) {
+            await setSession(ctx.channel, ctx.root, "active");
+            return;
+        }
+        if (result.errorMessage) {
+            // The stream's own error surface already rendered; don't hunt approvals
+            // on a failed turn.
+            await setSession(ctx.channel, ctx.root, "active");
+            return;
+        }
+        // Approvals are message state, not stream chunks — check fresh history.
+        let hasPending = false;
+        try {
+            const history = await config.runtime.loadHistory({
+                chatId: ctx.chatId,
+                principal: ctx.principal,
+            });
+            const secret = await resolveSigningSecret();
+            for (const pa of pendingApprovals(history)) {
+                hasPending = true;
+                if (pa.isConnect && pa.connectionName && config.authorizeUrl) {
+                    const url = config.authorizeUrl(pa.connectionName, {
+                        chatId: ctx.chatId,
+                        channelId: ctx.channel,
+                        // The EFFECTIVE thread (anchor included) — the host carries it
+                        // through connect-done so the resume renders where the card is.
+                        threadTs: threadTs ?? ctx.root,
+                        userId: ctx.userId,
+                        approvalId: pa.approvalId,
+                    });
+                    await api.postEphemeral({
+                        channel: ctx.channel,
+                        user: ctx.userId,
+                        ...(threadTs ? { thread_ts: threadTs } : {}),
+                        blocks: connectBlocks(pa.connectionName, url),
+                        text: `Connect ${pa.connectionName} to continue.`,
+                    });
+                }
+                else {
+                    const value = encodeAction({
+                        kind: "approval",
+                        chatId: ctx.chatId,
+                        approvalId: pa.approvalId,
+                        tool: pa.toolName,
+                        actor: ctx.userId,
+                    }, secret);
+                    await api.postMessage({
+                        channel: ctx.channel,
+                        ...(threadTs ? { thread_ts: threadTs } : {}),
+                        blocks: approvalBlocksV2(value, pa.toolName, pa.input),
+                        text: `Approve ${pa.toolName}?`,
+                    });
+                }
+            }
+        }
+        catch (e) {
+            console.error("[slack] approval rendering failed:", e);
+        }
+        await setSession(ctx.channel, ctx.root, hasPending ? "suspended" : "active");
+    }
+    /** Run one gated message inside the chat's turn lease. */
+    async function runLeasedMessage(ctx) {
+        const turnStartedAt = Date.now();
+        await setSession(ctx.channel, ctx.root, "processing");
+        const text = ctx.context
+            ? `${ctx.context}\n\nThe message addressed to you:\n${ctx.prompt}`
+            : ctx.prompt;
+        const message = {
+            id: newId(),
+            role: "user",
+            parts: [{ type: "text", text }],
+            metadata: { visibility: "user", createdAt: Date.now() },
+        };
+        try {
+            const res = await config.runtime.handleChat({
+                agent: config.agent,
+                chatId: ctx.chatId,
+                principal: ctx.principal,
+                message,
+            });
+            await renderTurn(res, { ...ctx, turnStartedAt });
+        }
+        catch (e) {
+            // Core's one-turn-per-chat refusal: the same quiet notice the lease gives.
+            if (isChatBusyError(e)) {
+                await api
+                    .postEphemeral({
+                    channel: ctx.channel,
+                    user: ctx.userId,
+                    ...(threadTsOf(ctx.root) ?? ctx.anchorTs ? { thread_ts: threadTsOf(ctx.root) ?? ctx.anchorTs } : {}),
+                    text: BUSY_NOTICE,
+                })
+                    .catch(() => { });
+                await setSession(ctx.channel, ctx.root, "active");
+                return;
+            }
+            // Never post raw internals into the channel: masked stream errors render
+            // through the renderer; a pre-stream throw gets the generic line.
+            console.error("[slack] turn failed:", e);
+            await api
+                .postMessage({
+                channel: ctx.channel,
+                thread_ts: threadTsOf(ctx.root) ?? ctx.anchorTs,
+                text: GENERIC_ERROR,
+            })
+                .catch(() => { });
+            await setSession(ctx.channel, ctx.root, "active");
+        }
+    }
+    // ── Deferred workers ───────────────────────────────────────────────────────
+    async function handleUserMessage(body, mode) {
+        const ev = body.event;
+        const teamId = body.team_id ?? "";
+        if (!ev.channel || !ev.ts)
+            return;
+        // Narrowed copy: the lease body below is a closure, where TS forgets the guard.
+        const channel = ev.channel;
+        // 1. Delivery dedupe — Slack retries reuse the event_id.
+        if (body.event_id && !(await config.claimOnce(`evt:${body.event_id}`, EVT_TTL)))
+            return;
+        // 2. Shape check — humans only, allowlisted subtypes, never the bot itself.
+        if (!isRenderableUserMessage(ev, config.botUserId))
+            return;
+        const userId = ev.user;
+        // 3. Message identity claim — one message arrives as several event shapes
+        //    (a channel mention fires BOTH app_mention and message.channels).
+        //    Claimed before any user-visible side effect so even a refusal notice
+        //    posts exactly once.
+        if (!(await config.claimOnce(`msg:${teamId}:${channel}:${ev.ts}`, MSG_TTL)))
+            return;
+        // 4. The chat this message belongs to. Un-threaded messages in a DM
+        //    channel always land on the `_dm` chat REGARDLESS of event shape —
+        //    a DM mention can arrive as app_mention too, and both shapes must
+        //    resolve to the same chat.
+        const root = ev.thread_ts ?? (channel.startsWith("D") ? DM_ROOT : ev.ts);
+        const chatId = slackChatId(config.appId, channel, root);
+        // For `_dm` chats the asking message anchors everything this turn posts
+        // (streams need a thread there; notices stay next to what they answer).
+        const anchorTs = ev.thread_ts ?? ev.ts;
+        const threadTs = threadTsOf(root) ?? anchorTs;
+        const existing = await config.threads.get(chatId);
+        if (mode === "thread-follow" && !existing)
+            return; // not our thread
+        // 5. Initiator ownership — one quiet notice, then silence.
+        if (existing && existing.initiatorUserId !== userId) {
+            if (await config.claimOnce(`note:${chatId}:${userId}`, NOTE_TTL)) {
+                await api
+                    .postEphemeral({
+                    channel: channel,
+                    user: userId,
+                    ...(threadTs ? { thread_ts: threadTs } : {}),
+                    text: `This is <@${existing.initiatorUserId}>'s conversation with the agent. Mention me in a new thread (or DM me) to start your own.`,
+                })
+                    .catch(() => { });
+            }
+            return;
+        }
+        // 6. The prompt.
+        const prompt = normalizeSlackText(ev.text ?? "", config.botUserId);
+        if (!prompt)
+            return;
+        // 7. Identity gate.
+        let principal = config.principal;
+        if (config.authorizeUser) {
+            let auth;
+            try {
+                auth = await config.authorizeUser({
+                    teamId,
+                    userId,
+                    channelId: channel,
+                    threadRoot: root,
+                    anchorTs,
+                    prompt,
+                });
+            }
+            catch (e) {
+                console.error("[slack] auth check failed:", e);
+                return;
+            }
+            if (!auth.allowed) {
+                if (auth.silent)
+                    return;
+                // Only pass thread_ts for a real thread reply — threading an ephemeral
+                // under a top-level mention hides it in a pane the user isn't viewing.
+                const ephemeralThread = ev.thread_ts ? { thread_ts: ev.thread_ts } : {};
+                try {
+                    if (auth.linkUrl) {
+                        await api.postEphemeral({
+                            channel: channel,
+                            user: userId,
+                            ...ephemeralThread,
+                            blocks: signInCard(auth.linkUrl, auth.message),
+                            text: auth.message ?? "Sign in to Latch to use this agent.",
+                        });
+                    }
+                    else {
+                        await api.postEphemeral({
+                            channel: channel,
+                            user: userId,
+                            ...ephemeralThread,
+                            text: auth.message ?? "You don't have access to this agent.",
+                        });
+                    }
+                }
+                catch (e) {
+                    console.error("[slack] ephemeral refused-notice failed, trying DM:", e);
+                    try {
+                        const dm = await api.openDm(userId);
+                        if (dm) {
+                            await api.postMessage({
+                                channel: dm,
+                                ...(auth.linkUrl ? { blocks: signInCard(auth.linkUrl, auth.message) } : {}),
+                                text: auth.message ?? "Sign in to Latch to use this agent.",
+                            });
+                        }
+                    }
+                    catch (e2) {
+                        console.error("[slack] DM fallback failed:", e2);
+                    }
+                }
+                return;
+            }
+            if (auth.principal !== undefined)
+                principal = auth.principal;
+        }
+        // 8. Turn lease — ONE live run per chat.
+        const busy = () => api.postEphemeral({
+            channel: channel,
+            user: userId,
+            ...(threadTs ? { thread_ts: threadTs } : {}),
+            text: BUSY_NOTICE,
+        });
+        await withTurnLease(config, chatId, busy, async () => {
+            // 9. Ownership record (inside the lease → no create race).
+            if (!existing) {
+                const owner = await config.threads.claim(chatId, {
+                    initiatorUserId: userId,
+                    teamId,
+                    createdAt: Date.now(),
+                });
+                if (owner.initiatorUserId !== userId)
+                    return; // lost an unlikely race
+            }
+            // 10. First engagement of a pre-existing human thread: seed context.
+            let context;
+            if (mode === "mention" && ev.thread_ts && !existing) {
+                try {
+                    const history = await config.runtime.loadHistory({ chatId, principal });
+                    if (history.length === 0) {
+                        const replies = await api.threadReplies(channel, ev.thread_ts);
+                        const prior = replies
+                            .filter((m) => m.ts !== ev.ts && !m.isBot && m.text.trim())
+                            .slice(-30);
+                        if (prior.length) {
+                            const lines = prior
+                                .map((m) => `${m.userId ? `@${m.userId}` : "user"}: ${normalizeSlackText(m.text, config.botUserId)}`)
+                                .join("\n");
+                            context = `Earlier messages in this Slack thread (for context):\n${lines}`;
+                        }
+                    }
+                }
+                catch (e) {
+                    console.error("[slack] thread context fetch failed:", e);
+                }
+            }
+            await runLeasedMessage({
+                chatId,
+                channel: channel,
+                root,
+                anchorTs,
+                userId,
+                prompt,
+                ...(context !== undefined ? { context } : {}),
+                principal,
+            });
+        });
+    }
+    async function handleSessionStop(body) {
+        const ev = body.event;
+        if (body.event_id && !(await config.claimOnce(`evt:${body.event_id}`, EVT_TTL)))
+            return;
+        if (!ev.channel)
+            return;
+        const root = ev.thread_ts ?? DM_ROOT;
+        const chatId = slackChatId(config.appId, ev.channel, root);
+        await config.threads.markStopped(chatId).catch((e) => {
+            console.error("[slack] markStopped failed:", e);
+        });
+        // Belt and braces: close any stream Slack says was live, and clear the
+        // status — it does NOT auto-clear on stop.
+        for (const streamTs of ev.streaming_message_ts ?? []) {
+            await api
+                .stopStream({ channel: ev.channel, ts: streamTs, markdown_text: "\n\n_Stopped._" })
+                .catch(() => { });
+        }
+        await setSession(ev.channel, root, "active");
+    }
+    async function handleInteraction(payload) {
+        const action = payload.actions?.[0];
+        const clicker = payload.user?.id ?? "";
+        const channel = payload.channel?.id ?? "";
+        if (!action || !clicker)
+            return;
+        // Interaction dedupe — Slack retries interactivity POSTs too.
+        if (payload.trigger_id && !(await config.claimOnce(`act:${payload.trigger_id}`, ACT_TTL))) {
+            return;
+        }
+        if (action.action_id !== APPROVE_ACTION && action.action_id !== DENY_ACTION)
+            return;
+        const secret = await resolveSigningSecret();
+        const decoded = action.value ? decodeAction(action.value, secret) : null;
+        const ephemeral = (text) => api
+            .postEphemeral({
+            channel,
+            user: clicker,
+            ...(payload.message?.thread_ts ? { thread_ts: payload.message.thread_ts } : {}),
+            text,
+        })
+            .catch(() => { });
+        if (!decoded) {
+            await ephemeral("This button has expired — ask the agent again.");
+            return;
+        }
+        // Actor-only: the tool executes with the REQUESTER's credentials, so only
+        // they may authorize it.
+        if (clicker !== decoded.actor) {
+            await ephemeral(`Only <@${decoded.actor}> can act on this approval.`);
+            return;
+        }
+        const parsed = parseSlackChatId(decoded.chatId);
+        if (!parsed || parsed.app !== config.appId)
+            return;
+        const approved = action.action_id === APPROVE_ACTION;
+        // Gate the clicker like a message author — the resume is a real turn.
+        let principal = config.principal;
+        if (config.authorizeUser) {
+            let auth;
+            try {
+                auth = await config.authorizeUser({
+                    teamId: payload.team?.id ?? payload.user?.team_id ?? "",
+                    userId: clicker,
+                    channelId: parsed.channel,
+                    threadRoot: parsed.root,
+                    prompt: "",
+                });
+            }
+            catch (e) {
+                console.error("[slack] interaction auth check failed:", e);
+                return;
+            }
+            if (!auth.allowed) {
+                if (!auth.silent) {
+                    await ephemeral(auth.message ?? "Sign in to Latch to act on approvals.");
+                }
+                return;
+            }
+            if (auth.principal !== undefined)
+                principal = auth.principal;
+        }
+        // An approval resume IS a turn — same lease as a message.
+        const busy = () => ephemeral(MID_TURN_NOTICE);
+        await withTurnLease(config, decoded.chatId, busy, async () => {
+            const turnStartedAt = Date.now();
+            try {
+                const res = await config.runtime.applyApproval({
+                    chatId: decoded.chatId,
+                    principal,
+                    decisions: [{ approvalId: decoded.approvalId, approved }],
+                });
+                if (payload.message?.ts) {
+                    await api
+                        .update({
+                        channel,
+                        ts: payload.message.ts,
+                        blocks: approvalResolvedBlocks(decoded.tool ?? "tool", approved),
+                        text: approved ? "Approved" : "Denied",
+                    })
+                        .catch((e) => console.error("[slack] card settle failed:", e));
+                }
+                await renderTurn(res, {
+                    chatId: decoded.chatId,
+                    channel: parsed.channel,
+                    root: parsed.root,
+                    // The card lives where the turn rendered — its thread anchors the
+                    // resume for `_dm` chats (whose id carries no root).
+                    ...(payload.message?.thread_ts || payload.message?.ts
+                        ? { anchorTs: payload.message.thread_ts ?? payload.message.ts }
+                        : {}),
+                    userId: clicker,
+                    ...(decoded.tool ? { resumedToolName: decoded.tool } : {}),
+                    principal,
+                    turnStartedAt,
+                });
+            }
+            catch (e) {
+                if (isChatBusyError(e))
+                    return void (await ephemeral(MID_TURN_NOTICE));
+                console.error("[slack] approval resume failed:", e);
+                await ephemeral(GENERIC_ERROR);
+            }
+        });
+    }
+    async function handleLifecycle(body) {
+        if (body.event_id && !(await config.claimOnce(`evt:${body.event_id}`, EVT_TTL)))
+            return;
+        if (!config.onLifecycle)
+            return;
+        const type = body.event.type === "tokens_revoked" ? "tokens_revoked" : "app_uninstalled";
+        await config.onLifecycle({ type, teamId: body.team_id ?? "" }).catch((e) => {
+            console.error("[slack] lifecycle hook failed:", e);
+        });
+    }
+    // ── The single webhook entrypoint ─────────────────────────────────────────
+    //
+    // PRE-ACK WORK IS EXACTLY THIS: read body → verify signature → minimal parse
+    // → route to a deferred worker → 200. Anything unroutable is 200 too, so
+    // Slack never retries what we'll never handle.
+    async function handleRequest(request) {
+        const raw = await request.text();
+        const validSig = verifySlackSignature({
+            signingSecret: await resolveSigningSecret(),
+            rawBody: raw,
+            signature: request.headers.get("x-slack-signature"),
+            timestamp: request.headers.get("x-slack-request-timestamp"),
+        });
+        if (!validSig)
+            return new Response("invalid signature", { status: 401 });
+        const contentType = request.headers.get("content-type") ?? "";
+        // Interactivity: form-encoded `payload=<json>`.
+        if (contentType.includes("application/x-www-form-urlencoded")) {
+            const payloadStr = new URLSearchParams(raw).get("payload");
+            if (payloadStr) {
+                try {
+                    const payload = JSON.parse(payloadStr);
+                    if (payload.type === "block_actions") {
+                        defer(handleInteraction(payload));
+                    }
+                }
+                catch (e) {
+                    console.error("[slack] interaction payload parse failed:", e);
+                }
+            }
+            return ok();
+        }
+        // Events API (JSON).
+        let body;
+        try {
+            body = JSON.parse(raw || "{}");
+        }
+        catch {
+            return ok();
+        }
+        if (body.type === "url_verification") {
+            return new Response(body.challenge ?? "", {
+                status: 200,
+                headers: { "content-type": "text/plain" },
+            });
+        }
+        if (body.type !== "event_callback" || !body.event)
+            return ok();
+        const ev = body.event;
+        const withEvent = body;
+        switch (ev.type) {
+            case "app_mention":
+                defer(handleUserMessage(withEvent, "mention"));
+                break;
+            case "message":
+                if (ev.channel_type === "im") {
+                    defer(handleUserMessage(withEvent, "dm"));
+                }
+                else if (ev.thread_ts) {
+                    defer(handleUserMessage(withEvent, "thread-follow"));
+                }
+                break;
+            case "agent_session_stopped":
+                defer(handleSessionStop(withEvent));
+                break;
+            case "tokens_revoked":
+            case "app_uninstalled":
+                defer(handleLifecycle(withEvent));
+                break;
+            default:
+                // app_home_opened, agent_session_title_changed, app_context_changed
+                // (v2.1), everything else: acknowledged and dropped.
+                break;
+        }
+        return ok();
+    }
+    // ── Host-driven entries (replays, OAuth resumes) ───────────────────────────
+    /**
+     * Run one already-gated message (the post-link replay). Takes the chat's
+     * turn lease like any other turn; a busy chat drops the replay (the user
+     * just linked — their next message will land normally).
+     */
+    async function runMessage(ctx) {
+        const chatId = slackChatId(config.appId, ctx.channel, ctx.root);
+        const principal = ctx.principal ?? config.principal;
+        const busy = async () => console.warn(`[slack] runMessage: chat ${chatId} busy — replay dropped`);
+        await withTurnLease(config, chatId, busy, async () => {
+            await config.threads.claim(chatId, {
+                initiatorUserId: ctx.userId,
+                teamId: config.teamId,
+                createdAt: Date.now(),
+            });
+            await runLeasedMessage({
+                chatId,
+                channel: ctx.channel,
+                root: ctx.root,
+                ...(ctx.anchorTs !== undefined ? { anchorTs: ctx.anchorTs } : {}),
+                userId: ctx.userId,
+                prompt: ctx.prompt,
+                ...(ctx.context !== undefined ? { context: ctx.context } : {}),
+                principal,
+            });
+        });
+    }
+    /**
+     * Approve a parked `connect_<name>` after its OAuth completed in the
+     * browser. Connect-only, verified against fresh history — a browser
+     * redirect must never be able to approve an arbitrary gated tool.
+     */
+    async function resumeApproval(ctx) {
+        const parsed = parseSlackChatId(ctx.chatId);
+        if (!parsed || parsed.app !== config.appId)
+            return;
+        const principal = ctx.principal ?? config.principal;
+        const history = await config.runtime.loadHistory({ chatId: ctx.chatId, principal });
+        const pending = pendingApprovals(history).find((pa) => pa.approvalId === ctx.approvalId);
+        if (!pending?.isConnect)
+            return;
+        const busy = async () => console.warn(`[slack] resumeApproval: chat ${ctx.chatId} busy — resume dropped`);
+        await withTurnLease(config, ctx.chatId, busy, async () => {
+            const turnStartedAt = Date.now();
+            await setSession(parsed.channel, parsed.root, "processing");
+            let res;
+            try {
+                res = await config.runtime.applyApproval({
+                    chatId: ctx.chatId,
+                    principal,
+                    decisions: [{ approvalId: ctx.approvalId, approved: true }],
+                });
+            }
+            catch (e) {
+                if (isChatBusyError(e)) {
+                    // Tell the person, not just the log: their connect finished but the
+                    // thread is mid-turn — the card stays, they press again.
+                    await busy();
+                    const threadTs = threadTsOf(parsed.root) ?? ctx.anchorTs;
+                    await api
+                        .postEphemeral({
+                        channel: parsed.channel,
+                        user: ctx.userId,
+                        ...(threadTs ? { thread_ts: threadTs } : {}),
+                        text: MID_TURN_NOTICE,
+                    })
+                        .catch(() => { });
+                    await setSession(parsed.channel, parsed.root, "active");
+                    return;
+                }
+                throw e;
+            }
+            await renderTurn(res, {
+                chatId: ctx.chatId,
+                channel: parsed.channel,
+                root: parsed.root,
+                ...(ctx.anchorTs !== undefined ? { anchorTs: ctx.anchorTs } : {}),
+                userId: ctx.userId,
+                resumedToolName: pending.toolName,
+                principal,
+                turnStartedAt,
+            });
+        });
+    }
+    return { handleRequest, runMessage, resumeApproval };
+}
+//# sourceMappingURL=slackChannel.js.map