experimental-ash 0.10.0 → 0.10.1

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # experimental-ash
 
+## 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.1";
 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,3 +1,4 @@
+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";
@@ -5,7 +6,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(":");
@@ -141,6 +142,14 @@ export function slackChannel(config = {}) {
         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();
     let chatPromise = null;
     async function getChat() {
         if (chatPromise)
@@ -166,6 +175,65 @@ 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 });
+                }));
+            });
             return { chat };
         })();
         chatPromise = promise;
@@ -243,44 +311,9 @@ export function slackChannel(config = {}) {
                     }
                     return new Response("ok", { status: 200 });
                 }
-                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 });
+                // 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 }));
             }),
         ],
         async receive(input, { send }) {

package/package.json

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