experimental-ash 0.10.0 → 0.10.2

package/CHANGELOG.md

@@ -1,5 +1,55 @@
 # 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
+
+- 05ab89c: fix(slack): eliminate duplicate replies on follow-up mentions in a thread
+
+  `slackChannel` registered its `chat.onNewMention` listener inside the route handler, but the chat SDK's `onNewMention` _pushes_ handlers to an internal list (it does not replace). On warm serverless workers the cached `chat` instance accumulated one listener per inbound webhook, so the N-th `app_mention` dispatched N independent agent turns. Symptom: the first mention in a thread replied once, the next replied twice, the next three times, etc. — reset only by a cold start.
+
+  Registration is now done once per `chat` instance inside `getChat()`. The route handler threads its per-request `send` / `waitUntil` to the listener through a per-`slackChannel` `AsyncLocalStorage` — `requestContext.run({ send, waitUntil }, () => chat.webhooks.slack(req, ...))`. A naive shared module slot would race under concurrent webhook deliveries (the chat SDK yields the event loop on `await req.text()` inside `webhooks.slack`, so a second request can overwrite the slot before the first listener fires, causing request A's mention to dispatch with request B's `send`). ALS binds the store to the async call tree, so each concurrent route invocation gets its own isolated context.
+
+  The mention dispatch also now runs under `waitUntil(send(...).catch(log))` instead of `await send(...)`, mirroring the interaction path. This lets the webhook return `200 OK` within Slack's ~3s ACK window even on cold starts, avoiding the secondary duplication mode where Slack retries the same `app_mention` payload after a slow ACK.
+
 ## 0.10.0
 
 ### Minor 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.0";
+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

@@ -5,7 +5,7 @@ import { createLogger } from "#internal/logging.js";
 import { buildSlackTurnMessage, collectSlackFileParts, createSlackFetchFile, } from "#public/channels/slack/attachments.js";
 import { deriveHitlResponse, isHitlAction, renderInputRequestBlocks, } from "#public/channels/slack/hitl.js";
 import { mergeUploadPolicy } from "#public/channels/upload-policy.js";
-import { defineChannel, POST } from "#public/definitions/defineChannel.js";
+import { defineChannel, POST, } from "#public/definitions/defineChannel.js";
 const log = createLogger("slack.channel");
 function decodeThreadId(id) {
     const parts = id.replace(/^slack:/u, "").split(":");
@@ -135,17 +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();
+    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.");
@@ -166,15 +294,17 @@ export function slackChannel(config = {}) {
                 userName: config.botName ?? "ash-agent",
             });
             await chat.initialize();
+            // 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,
@@ -184,102 +314,12 @@ 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);
                 }
-                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 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);
-                    await send(turnMessage, {
-                        auth: runOpts.auth,
-                        continuationToken,
-                        state: {
-                            serializedThread: thread.toJSON(),
-                            teamId: teamId ?? null,
-                        },
-                    });
-                });
                 return await chat.webhooks.slack(req, { waitUntil });
             }),
         ],
@@ -299,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.0",
+  "version": "0.10.2",
   "bin": {
     "ash": "./bin/ash.js",
     "experimental-ash": "./bin/ash.js"