@cuylabs/channel-slack-agent-core 0.7.0 → 0.9.0

package/README.md

@@ -8,7 +8,8 @@ surfaces for Express Events API, Socket Mode, Slack Assistant, app mentions,
 DMs, feedback, approvals, or human input.
 
 Generic Slack mechanics such as parsing, policy, history, setup, auth, targets,
-users, entrypoints, artifacts, and transports live in `@cuylabs/channel-slack`.
+users, entrypoints, artifacts, interactive stores/builders, response sinks, and
+transports live in `@cuylabs/channel-slack`.
 
 ## Install
 
@@ -22,7 +23,8 @@ Install Slack peer dependencies for the surfaces you use:
 npm install @slack/bolt @slack/web-api express
 ```
 
-Postgres-backed interactive request storage lazy-loads `pg` when you pass a
+Postgres-backed interactive request storage lives in
+`@cuylabs/channel-slack/interactive` and lazy-loads `pg` when you pass a
 connection string. Install `pg` only when your application uses that helper
 without injecting its own client.
 

package/dist/adapter/index.d.ts

@@ -1,12 +1,13 @@
-export { c as createSlackChannelAdapter } from '../adapter-B3CI611y.js';
-import { a as SlackChannelOptions } from '../types-CRWzJB5G.js';
-export { S as SlackChannelAdapter, b as SlackSessionStrategy, c as SlackStreamingMode, d as SlackToolStartEvent } from '../types-CRWzJB5G.js';
+export { c as createSlackChannelAdapter } from '../adapter-vbqtraAr.js';
+import { a as SlackChannelOptions } from '../types-BeGPexio.js';
+export { S as SlackChannelAdapter, b as SlackSessionStrategy, c as SlackStreamingMode, d as SlackToolStartEvent } from '../types-BeGPexio.js';
 import { SlackActivityInfo } from '@cuylabs/channel-slack/core';
 import '@cuylabs/agent-core';
-import '../options-BcDReOJv.js';
+import '../options-CGUfVStV.js';
 import '../artifacts/index.js';
 import '@cuylabs/channel-slack/artifacts';
-import '../interactive-o_NZb-Xg.js';
+import '../interactive-BigrPKnu.js';
+import '@cuylabs/channel-slack/interactive';
 
 /**
  * Session mapping — Slack activity info to agent-core session IDs.

package/dist/adapter/index.js

@@ -1,8 +1,8 @@
 import {
   createSlackChannelAdapter,
   createSlackSessionMap
-} from "../chunk-FQWFB54C.js";
-import "../chunk-TMADMHBN.js";
+} from "../chunk-XA7U3GRN.js";
+import "../chunk-VBGQD6JT.js";
 export {
   createSlackChannelAdapter,
   createSlackSessionMap

package/dist/{adapter-B3CI611y.d.ts → adapter-vbqtraAr.d.ts}

@@ -1,4 +1,4 @@
-import { a as SlackChannelOptions, S as SlackChannelAdapter } from './types-CRWzJB5G.js';
+import { a as SlackChannelOptions, S as SlackChannelAdapter } from './types-BeGPexio.js';
 
 /**
  * Slack Channel Adapter

package/dist/app-surface.d.ts

@@ -1,14 +1,15 @@
 import { AgentTurnSource, Logger } from '@cuylabs/agent-core';
 import { App } from '@slack/bolt';
 import { WebClient } from '@slack/web-api';
-import { C as CreateSlackAssistantBridgeOptions, b as SlackAssistantFeedbackConfig, S as SlackAssistantBridge } from './options-CdqBABcM.js';
-import { a as SlackChannelOptions } from './types-CRWzJB5G.js';
+import { C as CreateSlackAssistantBridgeOptions, d as SlackAssistantFeedbackConfig, S as SlackAssistantBridge } from './options-ByNm2o89.js';
+import { a as SlackChannelOptions } from './types-BeGPexio.js';
 import { SlackTurnRequestContext, SlackAssistantUtilities, SlackTurnPreparation } from '@cuylabs/channel-slack/core';
 import { SlackFeedbackHandler } from '@cuylabs/channel-slack/feedback';
-import { c as SlackInteractiveController } from './types-Crpil4kb.js';
+import { a as SlackInteractiveController } from './types-Bz4OYEAV.js';
 import { d as SlackAgentViewWorkflowController } from './types-CiwGU6zC.js';
-import './interactive-o_NZb-Xg.js';
-import './options-BcDReOJv.js';
+import './interactive-BigrPKnu.js';
+import '@cuylabs/channel-slack/interactive';
+import './options-CGUfVStV.js';
 import './artifacts/index.js';
 import '@cuylabs/channel-slack/artifacts';
 import '@cuylabs/channel-slack/assistant';

package/dist/app-surface.js

@@ -1,10 +1,10 @@
 import {
   installSlackAgentAppSurface
-} from "./chunk-7DUO5BMW.js";
-import "./chunk-MGBNGG4D.js";
+} from "./chunk-GKZRDNEB.js";
+import "./chunk-FJP6ZFUB.js";
 import "./chunk-ELR6MQD7.js";
-import "./chunk-FQWFB54C.js";
-import "./chunk-TMADMHBN.js";
+import "./chunk-XA7U3GRN.js";
+import "./chunk-VBGQD6JT.js";
 export {
   installSlackAgentAppSurface
 };

package/dist/app.d.ts

@@ -5,17 +5,18 @@ import { CreateSlackBoltAppOptions } from '@cuylabs/channel-slack/transports/htt
 import { SlackDirectAuthOptions, SlackDirectAuthMode } from '@cuylabs/channel-slack/auth';
 import { SlackAgentAppSurfaceOptions } from './app-surface.js';
 export { MountSlackAgentAppTurnRequestContext } from './app-surface.js';
-import { S as SlackAssistantBridge } from './options-CdqBABcM.js';
+import { S as SlackAssistantBridge } from './options-ByNm2o89.js';
 import '@cuylabs/agent-core';
 import '@slack/web-api';
-import './types-CRWzJB5G.js';
+import './types-BeGPexio.js';
 import '@cuylabs/channel-slack/core';
-import './options-BcDReOJv.js';
+import './options-CGUfVStV.js';
 import './artifacts/index.js';
 import '@cuylabs/channel-slack/artifacts';
-import './interactive-o_NZb-Xg.js';
+import './interactive-BigrPKnu.js';
+import '@cuylabs/channel-slack/interactive';
 import '@cuylabs/channel-slack/feedback';
-import './types-Crpil4kb.js';
+import './types-Bz4OYEAV.js';
 import './types-CiwGU6zC.js';
 import '@cuylabs/channel-slack/views';
 import '@cuylabs/channel-slack/assistant';

package/dist/app.js

@@ -1,11 +1,11 @@
 import {
   mountSlackAgentApp
-} from "./chunk-76SRS54H.js";
-import "./chunk-7DUO5BMW.js";
-import "./chunk-MGBNGG4D.js";
+} from "./chunk-KAEZPS3U.js";
+import "./chunk-GKZRDNEB.js";
+import "./chunk-FJP6ZFUB.js";
 import "./chunk-ELR6MQD7.js";
-import "./chunk-FQWFB54C.js";
-import "./chunk-TMADMHBN.js";
+import "./chunk-XA7U3GRN.js";
+import "./chunk-VBGQD6JT.js";
 export {
   mountSlackAgentApp
 };

package/dist/assistant/index.d.ts

@@ -1,12 +1,13 @@
-import { C as CreateSlackAssistantBridgeOptions, S as SlackAssistantBridge } from '../options-CdqBABcM.js';
-export { A as AssistantLifecycleArgs, a as AssistantThreadStartedArgs, M as MaybePromise, b as SlackAssistantFeedbackConfig, c as SlackAssistantSessionStrategy, d as SlackAssistantStatusContext, e as SlackAssistantThreadContextStoreLike, f as SlackAssistantThreadStartedContext, g as SlackAssistantTurnPreparation, h as SlackAssistantUserMessageContext, r as resolveAssistantSessionId } from '../options-CdqBABcM.js';
+import { C as CreateSlackAssistantBridgeOptions, S as SlackAssistantBridge } from '../options-ByNm2o89.js';
+export { A as AssistantLifecycleArgs, a as AssistantThreadStartedArgs, M as MaybePromise, b as SlackAssistantCancelControlOptions, c as SlackAssistantCancelControlVisibleWhen, d as SlackAssistantFeedbackConfig, e as SlackAssistantSessionStrategy, f as SlackAssistantStatusContext, g as SlackAssistantThreadContextStoreLike, h as SlackAssistantThreadStartedContext, i as SlackAssistantTurnCancelContext, j as SlackAssistantTurnControlsOptions, k as SlackAssistantTurnPreparation, l as SlackAssistantUserMessageContext, r as resolveAssistantSessionId } from '../options-ByNm2o89.js';
 export { ParsedAssistantUserMessage, createSlackAssistantThreadContextStore, parseSlackMessageActivityFromMessageEvent } from '@cuylabs/channel-slack/assistant';
 import '@cuylabs/agent-core';
 import '@slack/bolt';
 import '@slack/web-api';
 import '@cuylabs/channel-slack/core';
-import '../interactive-o_NZb-Xg.js';
-import '../options-BcDReOJv.js';
+import '../interactive-BigrPKnu.js';
+import '@cuylabs/channel-slack/interactive';
+import '../options-CGUfVStV.js';
 import '../artifacts/index.js';
 import '@cuylabs/channel-slack/artifacts';
 import '@cuylabs/channel-slack/feedback';

package/dist/assistant/index.js

@@ -3,9 +3,9 @@ import {
   createSlackAssistantThreadContextStore,
   parseSlackMessageActivityFromMessageEvent,
   resolveAssistantSessionId
-} from "../chunk-MGBNGG4D.js";
+} from "../chunk-FJP6ZFUB.js";
 import "../chunk-ELR6MQD7.js";
-import "../chunk-TMADMHBN.js";
+import "../chunk-VBGQD6JT.js";
 export {
   createSlackAssistantBridge,
   createSlackAssistantThreadContextStore,

package/dist/{chunk-TCNJY7QA.js → chunk-D4CSEAIF.js}

@@ -1,6 +1,6 @@
 import {
   createSlackChannelAdapter
-} from "./chunk-FQWFB54C.js";
+} from "./chunk-XA7U3GRN.js";
 
 // src/express.ts
 import {

package/dist/{chunk-MGBNGG4D.js → chunk-FJP6ZFUB.js}

@@ -7,10 +7,11 @@ import {
   UnsupportedSlackInteractiveRequestError,
   bridgeAgentEventsToSlack,
   resolveSlackEventBridgeOptions
-} from "./chunk-TMADMHBN.js";
+} from "./chunk-VBGQD6JT.js";
 
 // src/assistant/bridge.ts
 import { Assistant } from "@slack/bolt";
+import { resolveSlackTurnCancelActionId as resolveSlackTurnCancelActionId2 } from "@cuylabs/channel-slack/turn-controls";
 
 // src/assistant/options.ts
 var DEFAULT_INITIAL_REPLY = "Hi, how can I help?";
@@ -294,7 +295,7 @@ function createAssistantInteractiveResponder(params) {
 
 // src/assistant/lifecycle/user-message.ts
 function createUserMessageHandler(deps) {
-  const { options, feedbackBlock, sessionStrategy } = deps;
+  const { options, feedbackBlock, sessionStrategy, turnControlController } = deps;
   const taskDisplayMode = options.taskDisplayMode ?? "timeline";
   const messageFormatter = resolveSlackMessageFormatter(
     options.formatChatMarkdown ?? {}
@@ -497,6 +498,17 @@ function createUserMessageHandler(deps) {
       });
       const abortController = new AbortController();
       timeoutId = timeoutMs > 0 ? setTimeout(() => abortController.abort(), timeoutMs) : void 0;
+      const cancelControl = turnControlController?.createCancelControl({
+        abortController,
+        channel,
+        client,
+        logger: diagnosticsLogger,
+        sessionId,
+        ...teamId ? { teamId } : {},
+        threadTs,
+        userId: userId ?? "unknown"
+      });
+      cancelControl?.show("turn-start");
       await runWithSlackTurnContext(
         {
           slackActivity: parsed,
@@ -533,6 +545,7 @@ function createUserMessageHandler(deps) {
             const translated = (async function* () {
               try {
                 for await (const event of events) {
+                  cancelControl?.sync(event);
                   if (event.type === "error") {
                     translatedError = toError(
                       event.error
@@ -561,6 +574,8 @@ ${formatStreamError(translatedError)}`
 ${formatStreamError(translatedError)}`
                 };
                 yield { type: "complete" };
+              } finally {
+                cancelControl?.clear("turn-finished");
               }
             })();
             const finalText = await bridgeAgentEventsToSlack(
@@ -617,6 +632,213 @@ ${formatStreamError(translatedError)}`
   };
 }
 
+// src/assistant/turn-controls.ts
+import { randomUUID } from "crypto";
+import {
+  createSlackTurnCancelMessage,
+  registerSlackTurnCancelAction,
+  resolveSlackTurnCancelActionId
+} from "@cuylabs/channel-slack/turn-controls";
+function createSlackAssistantTurnControlController(options) {
+  const resolvedCancelOptions = resolveCancelOptions(options);
+  if (!resolvedCancelOptions) {
+    return void 0;
+  }
+  const cancelOptions = resolvedCancelOptions;
+  const actionId = resolveSlackTurnCancelActionId(cancelOptions.actionId);
+  const activeControls = /* @__PURE__ */ new Map();
+  function install(app) {
+    registerSlackTurnCancelAction(app, {
+      actionId,
+      onCancel: (context) => handleCancelAction(context)
+    });
+  }
+  function createCancelControl(controlOptions) {
+    const control = {
+      abortController: controlOptions.abortController,
+      channel: controlOptions.channel,
+      client: controlOptions.client,
+      controlId: randomUUID(),
+      logger: controlOptions.logger,
+      pending: Promise.resolve(),
+      sessionId: controlOptions.sessionId,
+      ...controlOptions.teamId ? { teamId: controlOptions.teamId } : {},
+      threadTs: controlOptions.threadTs,
+      userId: controlOptions.userId,
+      visible: false
+    };
+    activeControls.set(control.controlId, control);
+    return {
+      show(reason) {
+        showCancelControl(control, reason);
+      },
+      clear(reason) {
+        clearCancelControl(control, reason);
+      },
+      sync(event) {
+        syncCancelControlForEvent(control, event);
+      }
+    };
+  }
+  async function handleCancelAction(context) {
+    const control = activeControls.get(context.controlId);
+    if (!control) {
+      await context.deleteMessage().catch(() => void 0);
+      await acknowledge(context, cancelOptions.alreadyCompletedAck);
+      return;
+    }
+    if (context.userId !== control.userId) {
+      await acknowledge(context, cancelOptions.unauthorizedAck);
+      return;
+    }
+    clearCancelControl(control, "button-cancel");
+    activeControls.delete(control.controlId);
+    if (!control.abortController.signal.aborted) {
+      control.abortController.abort(createSlackTurnCancelledError());
+    }
+    await cancelOptions.onCancel?.({
+      controlId: control.controlId,
+      sessionId: control.sessionId,
+      channelId: control.channel,
+      threadTs: control.threadTs,
+      userId: control.userId,
+      ...control.teamId ? { teamId: control.teamId } : {}
+    });
+    await acknowledge(context, cancelOptions.canceledAck);
+  }
+  function showCancelControl(control, reason) {
+    if (control.visible || control.abortController.signal.aborted) {
+      return;
+    }
+    control.visible = true;
+    enqueueControlUpdate(control, "show", reason, async () => {
+      const message = createSlackTurnCancelMessage({
+        actionId,
+        controlId: control.controlId,
+        messageText: cancelOptions.messageText,
+        buttonText: cancelOptions.buttonText,
+        sessionId: control.sessionId
+      });
+      if (control.target) {
+        await control.client.chat.update({
+          channel: control.target.channel,
+          ts: control.target.ts,
+          text: message.text,
+          blocks: message.blocks
+        });
+        return;
+      }
+      const response = await control.client.chat.postMessage({
+        channel: control.channel,
+        thread_ts: control.threadTs,
+        text: message.text,
+        blocks: message.blocks
+      });
+      if (response.channel && response.ts) {
+        control.target = { channel: response.channel, ts: response.ts };
+      }
+    });
+  }
+  function clearCancelControl(control, reason) {
+    const terminal = isTerminalClearReason(reason);
+    if (terminal) {
+      activeControls.delete(control.controlId);
+    }
+    if (!control.visible) {
+      return;
+    }
+    control.visible = false;
+    enqueueControlUpdate(control, "clear", reason, async () => {
+      if (!control.target) {
+        return;
+      }
+      const target = control.target;
+      control.target = void 0;
+      await control.client.chat.delete({
+        channel: target.channel,
+        ts: target.ts
+      });
+    });
+  }
+  function syncCancelControlForEvent(control, event) {
+    switch (event.type) {
+      case "text-start":
+      case "text-delta":
+      case "text-end":
+        if (cancelOptions.visibleWhen === "before-output") {
+          clearCancelControl(control, "streaming-started");
+        }
+        break;
+      case "reasoning-start":
+      case "reasoning-delta":
+      case "reasoning-end":
+      case "tool-start":
+      case "approval-request":
+      case "human-input-request":
+        showCancelControl(control, event.type);
+        break;
+      case "status":
+        if (isWaitingForAgentStatus(event.status)) {
+          showCancelControl(control, `status:${event.status}`);
+        } else if (event.status === "idle" || event.status === "error") {
+          clearCancelControl(control, `status:${event.status}`);
+        }
+        break;
+      case "complete":
+        clearCancelControl(control, "turn-finished");
+        break;
+      case "error":
+        clearCancelControl(control, "turn-error");
+        break;
+      default:
+        break;
+    }
+  }
+  function enqueueControlUpdate(control, action, reason, update) {
+    control.pending = control.pending.then(update);
+    control.pending = control.pending.catch((error) => {
+      control.logger.warn?.("Slack turn cancel control update failed", {
+        action,
+        controlId: control.controlId,
+        error: formatErrorForLog(error),
+        reason,
+        sessionId: control.sessionId
+      });
+    });
+  }
+  async function acknowledge(context, text) {
+    if (text === false) {
+      return;
+    }
+    await context.acknowledgeEphemeral(text ?? "Canceled the running request.");
+  }
+  return { install, createCancelControl };
+}
+function resolveCancelOptions(options) {
+  if (!options?.cancel) {
+    return void 0;
+  }
+  const input = options.cancel === true ? {} : options.cancel;
+  return {
+    ...input,
+    visibleWhen: input.visibleWhen ?? "before-output",
+    canceledAck: input.canceledAck ?? "Canceled the running request.",
+    alreadyCompletedAck: input.alreadyCompletedAck ?? "That request is no longer running.",
+    unauthorizedAck: input.unauthorizedAck ?? "Only the user who started this request can cancel it."
+  };
+}
+function isWaitingForAgentStatus(status) {
+  return status === "processing" || status === "thinking" || status === "reasoning" || status === "calling-tool" || status === "waiting-approval" || status === "waiting-input";
+}
+function isTerminalClearReason(reason) {
+  return reason === "streaming-started" || reason === "turn-finished" || reason === "turn-error" || reason === "button-cancel";
+}
+function createSlackTurnCancelledError() {
+  return Object.assign(new Error("Slack turn was cancelled by the user."), {
+    category: "cancelled"
+  });
+}
+
 // src/assistant/bridge.ts
 import { createSlackAssistantThreadContextStore } from "@cuylabs/channel-slack/assistant";
 function createSlackAssistantBridge(options) {
@@ -634,13 +856,20 @@ function createSlackAssistantBridge(options) {
   const feedbackConfig = options.feedback === false ? void 0 : options.feedback ?? {};
   const feedbackBlock = feedbackConfig ? createSlackFeedbackBlock(feedbackConfig) : void 0;
   const feedbackActionId = feedbackConfig?.actionId ?? SLACK_FEEDBACK_ACTION_ID;
+  const turnControlController = createSlackAssistantTurnControlController(
+    options.turnControls
+  );
+  const turnCancelActionId = turnControlController ? resolveSlackTurnCancelActionId2(
+    resolveTurnCancelActionIdOption(options.turnControls)
+  ) : void 0;
   const threadStarted = createThreadStartedHandler(options);
   const threadContextChanged = createThreadContextChangedHandler();
   const threadContextStore = options.threadContextStore ?? createSlackAssistantThreadContextStore();
   const userMessage = createUserMessageHandler({
     options,
     feedbackBlock,
-    sessionStrategy
+    sessionStrategy,
+    ...turnControlController ? { turnControlController } : {}
   });
   const config = {
     threadStarted,
@@ -662,13 +891,21 @@ function createSlackAssistantBridge(options) {
         })
       });
     }
+    turnControlController?.install(app);
   }
   return {
     assistant,
     install,
-    ...feedbackConfig ? { feedbackActionId } : {}
+    ...feedbackConfig ? { feedbackActionId } : {},
+    ...turnCancelActionId ? { turnCancelActionId } : {}
   };
 }
+function resolveTurnCancelActionIdOption(options) {
+  if (!options || !options.cancel) {
+    return void 0;
+  }
+  return typeof options.cancel === "object" ? options.cancel.actionId : void 0;
+}
 
 // src/assistant/index.ts
 import {

package/dist/{chunk-7DUO5BMW.js → chunk-GKZRDNEB.js}

@@ -1,13 +1,12 @@
 import {
   createSlackAssistantBridge
-} from "./chunk-MGBNGG4D.js";
+} from "./chunk-FJP6ZFUB.js";
 import {
-  createSlackFeedbackBlock,
-  registerSlackFeedbackAction
+  createSlackFeedbackBlock
 } from "./chunk-ELR6MQD7.js";
 import {
   createSlackChannelAdapter
-} from "./chunk-FQWFB54C.js";
+} from "./chunk-XA7U3GRN.js";
 
 // src/app-surface.ts
 var DEFAULT_TIMEOUT_MS = 12e4;
@@ -49,7 +48,7 @@ function installSlackAgentAppSurface(boltApp, options) {
     ...resolveSession ? { resolveSession: toAssistantResolveSession(resolveSession) } : {},
     ...interactive ? { handleInteractiveRequest: interactive.handleInteractiveRequest } : {}
   });
-  boltApp.assistant(bridge.assistant);
+  bridge.install(boltApp);
   const channelAdapter = createSlackChannelAdapter({
     source: channelSource,
     sessionStrategy: assistantBridgeOptions.sessionStrategy,
@@ -99,15 +98,6 @@ function installSlackAgentAppSurface(boltApp, options) {
     } : {}
   });
   channelAdapter.mount(boltApp);
-  if (feedbackConfig) {
-    const feedbackSessionStrategy = assistantBridgeOptions.sessionStrategy ?? "thread-aware";
-    registerSlackFeedbackAction(boltApp, {
-      ...feedbackConfig,
-      resolveSessionId: (ctx) => resolveFeedbackSessionId(ctx, feedbackSessionStrategy),
-      onFeedback: feedbackConfig.onFeedback ?? (async (_ctx) => {
-      })
-    });
-  }
   interactive?.install(boltApp);
   viewWorkflows?.install(boltApp);
   return { bridge };
@@ -191,17 +181,6 @@ function formatErrorForLog(error) {
   }
   return String(error);
 }
-function resolveFeedbackSessionId(context, strategy) {
-  const threadTs = context.threadTs ?? context.messageTs;
-  switch (strategy) {
-    case "channel-id":
-      return context.channelId;
-    case "user-per-thread":
-      return `${context.channelId}:${threadTs}:${context.userId}`;
-    default:
-      return `${context.channelId}:${threadTs}`;
-  }
-}
 
 export {
   installSlackAgentAppSurface

package/dist/{chunk-VMVQIDNR.js → chunk-HHXAXSG6.js}

@@ -1,9 +1,9 @@
 import {
   installSlackAgentAppSurface
-} from "./chunk-7DUO5BMW.js";
+} from "./chunk-GKZRDNEB.js";
 import {
   createSlackAssistantBridge
-} from "./chunk-MGBNGG4D.js";
+} from "./chunk-FJP6ZFUB.js";
 
 // src/socket.ts
 import { createSlackSocketBoltApp } from "@cuylabs/channel-slack/transports/socket";

package/dist/{chunk-DJPKRKGP.js → chunk-JU5R6JZG.js}

@@ -1,6 +1,6 @@
 import {
   createSlackAssistantBridge
-} from "./chunk-MGBNGG4D.js";
+} from "./chunk-FJP6ZFUB.js";
 
 // src/express-assistant.ts
 import {

package/dist/{chunk-76SRS54H.js → chunk-KAEZPS3U.js}

@@ -1,6 +1,6 @@
 import {
   installSlackAgentAppSurface
-} from "./chunk-7DUO5BMW.js";
+} from "./chunk-GKZRDNEB.js";
 
 // src/app.ts
 import {