experimental-ash 0.10.1 → 0.10.2

package/CHANGELOG.md

@@ -1,5 +1,43 @@
 # experimental-ash
 
+## 0.10.2
+
+### Patch Changes
+
+- 9ac4a70: fix(slack): capture send once and await it inside the mention listener
+
+  The chat SDK defers mention handler invocation through the `waitUntil`
+  callback passed into `chat.webhooks.slack`, so the listener fires
+  after the route handler has returned. Per-request `send` therefore
+  cannot be threaded through any scope-based mechanism — by the time
+  the listener runs, the route's scope is gone and dispatches drop on
+  the floor (workflow never starts). The previous attempt to thread
+  `waitUntil(send)` through a per-request map also lost the dispatch:
+  the listener's `waitUntil(send)` push landed _after_ the dispatcher
+  had already snapshotted its `backgroundTasks` array into
+  `event.waitUntil(Promise.allSettled(backgroundTasks))`, so the send
+  promise was orphaned and the lambda could terminate mid-RPC.
+
+  `SendFn` is functionally identical across requests for a given
+  channel (`createSendFn` closes only over the bundled runtime, the
+  channel adapter, and the channel name — all stable). The channel now
+  captures `send` from the first request into a closure-scoped slot and
+  reuses it for every subsequent mention dispatch. The listener
+  `await`s send directly, so the chat SDK's outer dispatch IIFE awaits
+  the full send promise, which keeps the lambda alive through workflow
+  start under the request's `event.waitUntil`. No per-request lookup
+  map, no body parsing in the route handler, no request reconstruction
+  — the mention path is `if (!capturedSend) capturedSend = send; return
+chat.webhooks.slack(req, { waitUntil })`.
+
+  Also refactors `slackChannel.ts` for readability: extracts the mention
+  listener and the interactive-payload handler as named file-scoped
+  helpers (`buildMentionListener`, `handleInteractionRequest`).
+  `slackChannel()` shrinks from ~316 lines to ~105 and reads
+  top-to-bottom — configure → `getChat` factory → `defineChannel` with
+  a route handler that branches interaction vs mention and otherwise
+  just forwards to the SDK.
+
 ## 0.10.1
 
 ### Patch Changes

package/dist/src/internal/application/package.js

@@ -6,7 +6,7 @@ import { ASH_PACKAGE_NAME } from "#package-name.js";
 let cachedPackageInfo;
 // The package build stamps the published version into `dist` so bundled
 // deployments can still report package metadata without resolving package.json.
-const BUNDLED_FALLBACK_PACKAGE_VERSION = "0.10.1";
+const BUNDLED_FALLBACK_PACKAGE_VERSION = "0.10.2";
 const BUNDLED_FALLBACK_PACKAGE_VERSION_PLACEHOLDER = "__ASH_PACKAGE_VERSION_PLACEHOLDER__";
 const WORKFLOW_MODULE_ALIASES = {
     "workflow/api": "src/compiled/@workflow/core/runtime.js",

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

@@ -1,4 +1,3 @@
-import { AsyncLocalStorage } from "node:async_hooks";
 import { createSlackAdapter } from "#compiled/@chat-adapter/slack/index.js";
 import { createMemoryState } from "#compiled/@chat-adapter/state-memory/index.js";
 import { ThreadImpl, } from "#compiled/chat/index.js";
@@ -136,25 +135,145 @@ function defaultInputRequestedHandler() {
         });
     };
 }
+/**
+ * Build the once-registered `onNewMention` listener for a `Chat`
+ * instance. The chat SDK defers handler invocation through the
+ * `waitUntil` callback we pass into `webhooks.slack`, so the listener
+ * cannot rely on any per-request scope from the route handler. It
+ * uses `getSend` to look up the channel's captured `send` (which is
+ * functionally identical across requests — `createSendFn` closes only
+ * over the bundled runtime + adapter + channel name, all stable) and
+ * awaits it directly. The route's `event.waitUntil` keeps the lambda
+ * alive through the SDK's dispatch IIFE, which awaits this listener,
+ * which awaits send — so the workflow start completes before the
+ * lambda may terminate.
+ */
+function buildMentionListener(config, uploadPolicy, getSend) {
+    return async (thread, message) => {
+        const raw = message.raw;
+        // Slack delivers `app_mention` and `message.channels` for the same
+        // utterance; only the former is the listener's job.
+        if (raw?.type !== "app_mention")
+            return;
+        const send = getSend();
+        if (!send) {
+            log.warn("slack mention received before any request captured send");
+            return;
+        }
+        const teamId = raw.team_id ?? raw.team;
+        const slackCtx = {
+            thread,
+            slack: buildSlackApiHandle(thread, config.credentials?.botToken, teamId),
+        };
+        const runOpts = config.run ? await config.run(slackCtx, message) : { auth: null };
+        if (runOpts === null)
+            return;
+        if (config.onMention) {
+            try {
+                await config.onMention(slackCtx, message);
+            }
+            catch (error) {
+                log.error("onMention handler failed", { error });
+            }
+        }
+        const decoded = decodeThreadId(thread.id ?? "");
+        const continuationToken = `slack:${decoded.channelId}:${decoded.threadTs}`;
+        const fileParts = collectSlackFileParts(message, uploadPolicy);
+        const turnMessage = buildSlackTurnMessage(message.text, fileParts);
+        try {
+            await send(turnMessage, {
+                auth: runOpts.auth,
+                continuationToken,
+                state: {
+                    serializedThread: thread.toJSON(),
+                    teamId: teamId ?? null,
+                },
+            });
+        }
+        catch (error) {
+            log.error("mention delivery failed", { error });
+        }
+    };
+}
+/**
+ * Handle a Slack `block_actions` interactive payload (button clicks,
+ * select changes, modal submits). HITL `ash_input:*` actions resume
+ * their paused session via `send`; non-HITL actions are forwarded to
+ * `config.onInteraction`. Always returns `Response("ok")` — dispatch
+ * runs under `waitUntil` so the webhook ACKs immediately.
+ */
+async function handleInteractionRequest(rawBody, ctx, config) {
+    const ack = new Response("ok", { status: 200 });
+    const params = new URLSearchParams(rawBody);
+    const payloadStr = params.get("payload");
+    if (!payloadStr)
+        return ack;
+    let interaction;
+    try {
+        interaction = parseBlockActionsPayload(JSON.parse(payloadStr));
+    }
+    catch {
+        log.warn("failed to parse Slack interaction payload");
+        return ack;
+    }
+    if (!interaction)
+        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 },
+        })
+            .catch((error) => {
+            log.error("HITL interaction delivery failed", { error });
+        }));
+    }
+    const onInteraction = config.onInteraction;
+    if (onInteraction) {
+        const customActions = interaction.actions.filter((a) => !isHitlAction(a.actionId));
+        if (customActions.length > 0) {
+            const chatModule = await import("#compiled/chat/index.js");
+            const thread = new chatModule.ThreadImpl({
+                adapterName: "slack",
+                channelId: interaction.channelId,
+                id: `slack:${interaction.channelId}:${interaction.threadTs}`,
+                isDM: false,
+            });
+            const slackCtx = {
+                thread,
+                slack: buildSlackApiHandle(thread, 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;
+}
 export function slackChannel(config = {}) {
     const uploadPolicy = mergeUploadPolicy(config.uploadPolicy);
-    const slackFetchFile = createSlackFetchFile({
-        botToken: config.credentials?.botToken,
-    });
+    const slackFetchFile = createSlackFetchFile({ botToken: config.credentials?.botToken });
     const stateAdapter = config.stateAdapter ?? createMemoryState();
-    // Threads per-request `send`/`waitUntil` to the once-registered
-    // `onNewMention` listener. A shared mutable slot would race under
-    // concurrent webhook deliveries — `webhooks.slack` yields on
-    // `await req.text()`, so request B could overwrite A's slot before A's
-    // listener fires. ALS scopes the store to each route's async call tree.
-    // Allowlisted in `scripts/guard-agents-rules-baseline.json` (rule 19);
-    // this is channel-local request state, not Ash runtime state.
-    const requestContext = new AsyncLocalStorage();
+    const inputHandler = config.events?.["input.requested"] ?? defaultInputRequestedHandler();
+    // The chat SDK defers mention handler invocation past the route
+    // handler returning, so the listener can't read `send` off the
+    // current request. Capture it on the first request and reuse it —
+    // `createSendFn` closes only over the runtime + adapter + channel
+    // name, all stable across requests, so the captured instance works
+    // for every subsequent dispatch.
+    let capturedSend = null;
     let chatPromise = null;
     async function getChat() {
         if (chatPromise)
             return chatPromise;
-        const promise = (async () => {
+        chatPromise = (async () => {
             const { botToken, signingSecret, webhookVerifier } = resolveSlackAdapterCredentials(config.credentials);
             if (!botToken) {
                 throw new Error("slackChannel requires a bot token. Pass credentials.botToken or set SLACK_BOT_TOKEN.");
@@ -175,74 +294,17 @@ export function slackChannel(config = {}) {
                 userName: config.botName ?? "ash-agent",
             });
             await chat.initialize();
-            // Register exactly once per chat instance — the chat SDK's
-            // `onNewMention` pushes handlers (does not replace), so registering
-            // on every webhook accumulates listeners on warm workers and the
-            // N-th `app_mention` dispatches N times.
-            chat.onNewMention(async (thread, message) => {
-                const rawEvent = message.raw;
-                // Slack sends both `app_mention` and `message.channels` for the same
-                // utterance. The Chat SDK dedup relies on in-memory state that doesn't
-                // survive serverless invocations, so both events reach this handler.
-                // Only process `app_mention` to prevent duplicate runs.
-                if (rawEvent?.type !== "app_mention")
-                    return;
-                const ctx = requestContext.getStore();
-                if (!ctx) {
-                    // Defensive: the chat SDK invokes handlers inside the
-                    // `requestContext.run(...)` tree below, so this should never
-                    // miss. Log and drop in case a future SDK ever defers
-                    // invocation (e.g. via a queue or `setImmediate`).
-                    log.warn("slack mention received but no request context is active");
-                    return;
-                }
-                const teamId = rawEvent.team_id ?? rawEvent.team;
-                const slackCtx = {
-                    thread,
-                    slack: buildSlackApiHandle(thread, config.credentials?.botToken, teamId),
-                };
-                const runOpts = config.run ? await config.run(slackCtx, message) : { auth: null };
-                if (runOpts === null)
-                    return;
-                if (config.onMention) {
-                    try {
-                        await config.onMention(slackCtx, message);
-                    }
-                    catch (error) {
-                        log.error("onMention handler failed", { error });
-                    }
-                }
-                const decoded = decodeThreadId(thread.id ?? "");
-                const continuationToken = `slack:${decoded.channelId}:${decoded.threadTs}`;
-                const fileParts = collectSlackFileParts(message, uploadPolicy);
-                const turnMessage = buildSlackTurnMessage(message.text, fileParts);
-                // Dispatch via `waitUntil` so the webhook ACKs within Slack's ~3s
-                // window even on cold starts. Awaiting `send` here would let a
-                // slow dispatch push the response past 3s and trigger Slack
-                // retries of the same `app_mention` (which the type filter
-                // cannot dedupe). Errors are logged; Slack already got its 200.
-                ctx.waitUntil(ctx
-                    .send(turnMessage, {
-                    auth: runOpts.auth,
-                    continuationToken,
-                    state: {
-                        serializedThread: thread.toJSON(),
-                        teamId: teamId ?? null,
-                    },
-                })
-                    .catch((error) => {
-                    log.error("mention delivery failed", { error });
-                }));
-            });
+            // Register once per chat instance — `onNewMention` pushes
+            // handlers (does not replace), so registering per request would
+            // accumulate listeners on warm workers.
+            chat.onNewMention(buildMentionListener(config, uploadPolicy, () => capturedSend));
             return { chat };
         })();
-        chatPromise = promise;
-        promise.catch(() => {
+        chatPromise.catch(() => {
             chatPromise = null;
         });
-        return promise;
+        return chatPromise;
     }
-    const inputHandler = config.events?.["input.requested"] ?? defaultInputRequestedHandler();
     return defineChannel({
         state: { serializedThread: null, teamId: null },
         fetchFile: slackFetchFile,
@@ -252,68 +314,13 @@ export function slackChannel(config = {}) {
         routes: [
             POST(config.route ?? "/ash/v1/slack", async (req, { send, waitUntil }) => {
                 const { chat } = await getChat();
+                if (!capturedSend)
+                    capturedSend = send;
                 const contentType = req.headers.get("content-type") ?? "";
                 if (contentType.includes("application/x-www-form-urlencoded")) {
-                    const formData = await req.text();
-                    const params = new URLSearchParams(formData);
-                    const payloadStr = params.get("payload");
-                    if (payloadStr) {
-                        try {
-                            const payload = JSON.parse(payloadStr);
-                            const interaction = parseBlockActionsPayload(payload);
-                            if (interaction) {
-                                const continuationToken = `slack:${interaction.channelId}:${interaction.threadTs}`;
-                                const inputResponses = [];
-                                for (const action of interaction.actions) {
-                                    const response = deriveHitlResponse(action);
-                                    if (response !== null) {
-                                        inputResponses.push(response);
-                                    }
-                                }
-                                if (inputResponses.length > 0) {
-                                    waitUntil(send({ inputResponses }, {
-                                        auth: null,
-                                        continuationToken,
-                                        state: {
-                                            serializedThread: null,
-                                            teamId: interaction.teamId ?? null,
-                                        },
-                                    }).catch((error) => {
-                                        log.error("HITL interaction delivery failed", { error });
-                                    }));
-                                }
-                                if (config.onInteraction) {
-                                    const customActions = interaction.actions.filter((a) => !isHitlAction(a.actionId));
-                                    if (customActions.length > 0) {
-                                        const chatModule = await import("#compiled/chat/index.js");
-                                        const thread = new chatModule.ThreadImpl({
-                                            adapterName: "slack",
-                                            channelId: interaction.channelId,
-                                            id: `slack:${interaction.channelId}:${interaction.threadTs}`,
-                                            isDM: false,
-                                        });
-                                        const slackCtx = {
-                                            thread,
-                                            slack: buildSlackApiHandle(thread, config.credentials?.botToken, interaction.teamId),
-                                        };
-                                        for (const action of customActions) {
-                                            waitUntil(Promise.resolve(config.onInteraction(action, slackCtx)).catch((error) => {
-                                                log.error("custom interaction handler failed", { error });
-                                            }));
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                        catch {
-                            log.warn("failed to parse Slack interaction payload");
-                        }
-                    }
-                    return new Response("ok", { status: 200 });
+                    return handleInteractionRequest(await req.text(), { send, waitUntil }, config);
                 }
-                // Scope `send` / `waitUntil` to this request's async call tree so
-                // the `onNewMention` listener picks them up via `getStore()`.
-                return await requestContext.run({ send, waitUntil }, () => chat.webhooks.slack(req, { waitUntil }));
+                return await chat.webhooks.slack(req, { waitUntil });
             }),
         ],
         async receive(input, { send }) {
@@ -332,10 +339,7 @@ export function slackChannel(config = {}) {
             return send(input.message, {
                 auth: input.auth,
                 continuationToken: `slack:${channelId}:`,
-                state: {
-                    serializedThread: thread.toJSON(),
-                    teamId: null,
-                },
+                state: { serializedThread: thread.toJSON(), teamId: null },
             });
         },
         events: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "experimental-ash",
-  "version": "0.10.1",
+  "version": "0.10.2",
   "bin": {
     "ash": "./bin/ash.js",
     "experimental-ash": "./bin/ash.js"