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

package/dist/app-surface.d.ts

@@ -1,7 +1,7 @@
 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 { C as CreateSlackAssistantBridgeOptions, d as SlackAssistantFeedbackConfig, S as SlackAssistantBridge } from './options-C7-VXmhD.js';
 import { a as SlackChannelOptions } from './types-CRWzJB5G.js';
 import { SlackTurnRequestContext, SlackAssistantUtilities, SlackTurnPreparation } from '@cuylabs/channel-slack/core';
 import { SlackFeedbackHandler } from '@cuylabs/channel-slack/feedback';

package/dist/app-surface.js

@@ -1,7 +1,7 @@
 import {
   installSlackAgentAppSurface
-} from "./chunk-7DUO5BMW.js";
-import "./chunk-MGBNGG4D.js";
+} from "./chunk-6T6N4MRK.js";
+import "./chunk-7YZWCSML.js";
 import "./chunk-ELR6MQD7.js";
 import "./chunk-FQWFB54C.js";
 import "./chunk-TMADMHBN.js";

package/dist/app.d.ts

@@ -5,7 +5,7 @@ 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-C7-VXmhD.js';
 import '@cuylabs/agent-core';
 import '@slack/web-api';
 import './types-CRWzJB5G.js';

package/dist/app.js

@@ -1,8 +1,8 @@
 import {
   mountSlackAgentApp
-} from "./chunk-76SRS54H.js";
-import "./chunk-7DUO5BMW.js";
-import "./chunk-MGBNGG4D.js";
+} from "./chunk-236WN6JD.js";
+import "./chunk-6T6N4MRK.js";
+import "./chunk-7YZWCSML.js";
 import "./chunk-ELR6MQD7.js";
 import "./chunk-FQWFB54C.js";
 import "./chunk-TMADMHBN.js";

package/dist/assistant/index.d.ts

@@ -1,5 +1,5 @@
-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-C7-VXmhD.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-C7-VXmhD.js';
 export { ParsedAssistantUserMessage, createSlackAssistantThreadContextStore, parseSlackMessageActivityFromMessageEvent } from '@cuylabs/channel-slack/assistant';
 import '@cuylabs/agent-core';
 import '@slack/bolt';

package/dist/assistant/index.js

@@ -3,7 +3,7 @@ import {
   createSlackAssistantThreadContextStore,
   parseSlackMessageActivityFromMessageEvent,
   resolveAssistantSessionId
-} from "../chunk-MGBNGG4D.js";
+} from "../chunk-7YZWCSML.js";
 import "../chunk-ELR6MQD7.js";
 import "../chunk-TMADMHBN.js";
 export {

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

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

package/dist/{chunk-DJPKRKGP.js → chunk-2R7B7NJR.js}

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

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

@@ -1,9 +1,8 @@
 import {
   createSlackAssistantBridge
-} from "./chunk-MGBNGG4D.js";
+} from "./chunk-7YZWCSML.js";
 import {
-  createSlackFeedbackBlock,
-  registerSlackFeedbackAction
+  createSlackFeedbackBlock
 } from "./chunk-ELR6MQD7.js";
 import {
   createSlackChannelAdapter
@@ -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-MGBNGG4D.js → chunk-7YZWCSML.js}

@@ -11,6 +11,7 @@ import {
 
 // 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-VMVQIDNR.js → chunk-YSDFYHPC.js}

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

package/dist/express-assistant.d.ts

@@ -3,7 +3,7 @@ import { Application } from 'express';
 import { App, ExpressReceiver } from '@slack/bolt';
 import { CreateSlackBoltAppOptions } from '@cuylabs/channel-slack/transports/http';
 import { SlackDirectAuthOptions, SlackDirectAuthMode } from '@cuylabs/channel-slack/auth';
-import { C as CreateSlackAssistantBridgeOptions, b as SlackAssistantFeedbackConfig, S as SlackAssistantBridge } from './options-CdqBABcM.js';
+import { C as CreateSlackAssistantBridgeOptions, d as SlackAssistantFeedbackConfig, S as SlackAssistantBridge } from './options-C7-VXmhD.js';
 import { SlackFeedbackHandler } from '@cuylabs/channel-slack/feedback';
 import '@cuylabs/agent-core';
 import '@slack/web-api';

package/dist/express-assistant.js

@@ -1,7 +1,7 @@
 import {
   mountSlackAssistantAgent
-} from "./chunk-DJPKRKGP.js";
-import "./chunk-MGBNGG4D.js";
+} from "./chunk-2R7B7NJR.js";
+import "./chunk-7YZWCSML.js";
 import "./chunk-ELR6MQD7.js";
 import "./chunk-TMADMHBN.js";
 export {

package/dist/history/index.d.ts

@@ -4,7 +4,7 @@ import { MountSlackAgentAppTurnRequestContext } from '../app-surface.js';
 import { a as SlackContextFragmentPayload } from '../context-fragments-CQEDcjYR.js';
 import '@slack/bolt';
 import '@slack/web-api';
-import '../options-CdqBABcM.js';
+import '../options-C7-VXmhD.js';
 import '@cuylabs/channel-slack/core';
 import '../interactive-o_NZb-Xg.js';
 import '../options-BcDReOJv.js';

package/dist/index.d.ts

@@ -6,7 +6,7 @@ export { c as createSlackChannelAdapter } from './adapter-B3CI611y.js';
 export { S as SlackChannelAdapter, a as SlackChannelOptions, b as SlackSessionStrategy, c as SlackStreamingMode, d as SlackToolStartEvent } from './types-CRWzJB5G.js';
 export { SlackSessionMap, createSlackSessionMap } from './adapter/index.js';
 export { createSlackAssistantBridge } from './assistant/index.js';
-export { A as AssistantLifecycleArgs, a as AssistantThreadStartedArgs, C as CreateSlackAssistantBridgeOptions, M as MaybePromise, S as SlackAssistantBridge, 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';
+export { A as AssistantLifecycleArgs, a as AssistantThreadStartedArgs, C as CreateSlackAssistantBridgeOptions, M as MaybePromise, S as SlackAssistantBridge, 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-C7-VXmhD.js';
 export { ParsedAssistantUserMessage, createSlackAssistantThreadContextStore, parseSlackMessageActivityFromMessageEvent } from '@cuylabs/channel-slack/assistant';
 export { CreateSlackFinalResponseArtifactPublisherOptions, SlackFinalResponseArtifactContext, SlackFinalResponseArtifactDeliveryMode, SlackFinalResponseArtifactPublisher, SlackFinalResponseArtifactResult, SlackFinalResponseArtifactValueResolver, createSlackFinalResponseArtifactPublisher } from './artifacts/index.js';
 export { LoadSlackAgentTurnHistoryContextOptions, SlackAgentTurnHistoryContextResult, SlackAgentTurnHistoryOptions, SlackAgentTurnHistoryProfileResolver, emptySlackAgentTurnHistoryContextResult, loadSlackAgentTurnHistoryContext } from './history/index.js';

package/dist/index.js

@@ -50,10 +50,10 @@ import {
 } from "./chunk-C7CHMYV6.js";
 import {
   mountSlackAgentApp
-} from "./chunk-76SRS54H.js";
+} from "./chunk-236WN6JD.js";
 import {
   mountSlackAssistantAgent
-} from "./chunk-DJPKRKGP.js";
+} from "./chunk-2R7B7NJR.js";
 import {
   mountSlackAgent
 } from "./chunk-TCNJY7QA.js";
@@ -64,14 +64,14 @@ import {
 import {
   mountSlackAgentAppSocket,
   mountSlackAssistantAgentSocket
-} from "./chunk-VMVQIDNR.js";
-import "./chunk-7DUO5BMW.js";
+} from "./chunk-YSDFYHPC.js";
+import "./chunk-6T6N4MRK.js";
 import {
   createSlackAssistantBridge,
   createSlackAssistantThreadContextStore,
   parseSlackMessageActivityFromMessageEvent,
   resolveAssistantSessionId
-} from "./chunk-MGBNGG4D.js";
+} from "./chunk-7YZWCSML.js";
 import "./chunk-ELR6MQD7.js";
 import {
   createSlackChannelAdapter,

package/dist/{options-CdqBABcM.d.ts → options-C7-VXmhD.d.ts}

@@ -7,6 +7,29 @@ import { S as SlackEventBridgeOptions } from './options-BcDReOJv.js';
 import { SlackFeedbackBlockOptions, SlackFeedbackHandler } from '@cuylabs/channel-slack/feedback';
 import { ParsedAssistantUserMessage } from '@cuylabs/channel-slack/assistant';
 
+type SlackAssistantCancelControlVisibleWhen = "before-output" | "always-while-active";
+interface SlackAssistantCancelControlOptions {
+    actionId?: string;
+    buttonText?: string;
+    messageText?: string;
+    visibleWhen?: SlackAssistantCancelControlVisibleWhen;
+    canceledAck?: string | false;
+    alreadyCompletedAck?: string | false;
+    unauthorizedAck?: string | false;
+    onCancel?: (context: SlackAssistantTurnCancelContext) => MaybePromise<void>;
+}
+interface SlackAssistantTurnControlsOptions {
+    cancel?: true | SlackAssistantCancelControlOptions;
+}
+interface SlackAssistantTurnCancelContext {
+    controlId: string;
+    sessionId: string;
+    channelId: string;
+    threadTs: string;
+    userId: string;
+    teamId?: string;
+}
+
 /**
  * Session strategies for the Bolt Assistant bridge.
  *
@@ -187,6 +210,13 @@ interface CreateSlackAssistantBridgeOptions {
      * - `false`: omit the feedback block entirely.
      */
     feedback?: SlackAssistantFeedbackConfig | false;
+    /**
+     * Optional active-turn controls rendered in Slack while an assistant turn is
+     * running. The cancel control aborts the underlying `AgentTurnSource` via
+     * the per-turn `AbortSignal`, so any runtime implementing that contract can
+     * participate without Slack-specific code.
+     */
+    turnControls?: SlackAssistantTurnControlsOptions;
     /**
      * Bridge options forwarded to `bridgeAgentEventsToSlack`. Streaming mode is
      * pinned to `"chat-stream"` and cannot be overridden here.
@@ -283,6 +313,11 @@ interface SlackAssistantBridge {
      * The resolved feedback action id, or `undefined` when feedback is disabled.
      */
     feedbackActionId?: string;
+    /**
+     * The resolved cancel action id, or `undefined` when turn cancel controls are
+     * disabled.
+     */
+    turnCancelActionId?: string;
 }
 
-export { type AssistantLifecycleArgs as A, type CreateSlackAssistantBridgeOptions as C, type MaybePromise as M, type SlackAssistantBridge as S, type AssistantThreadStartedArgs as a, type SlackAssistantFeedbackConfig as b, type SlackAssistantSessionStrategy as c, type SlackAssistantStatusContext as d, type SlackAssistantThreadContextStoreLike as e, type SlackAssistantThreadStartedContext as f, type SlackAssistantTurnPreparation as g, type SlackAssistantUserMessageContext as h, resolveAssistantSessionId as r };
+export { type AssistantLifecycleArgs as A, type CreateSlackAssistantBridgeOptions as C, type MaybePromise as M, type SlackAssistantBridge as S, type AssistantThreadStartedArgs as a, type SlackAssistantCancelControlOptions as b, type SlackAssistantCancelControlVisibleWhen as c, type SlackAssistantFeedbackConfig as d, type SlackAssistantSessionStrategy as e, type SlackAssistantStatusContext as f, type SlackAssistantThreadContextStoreLike as g, type SlackAssistantThreadStartedContext as h, type SlackAssistantTurnCancelContext as i, type SlackAssistantTurnControlsOptions as j, type SlackAssistantTurnPreparation as k, type SlackAssistantUserMessageContext as l, resolveAssistantSessionId as r };

package/dist/socket.d.ts

@@ -1,7 +1,7 @@
 import { App } from '@slack/bolt';
 import { CreateSlackSocketBoltAppOptions } from '@cuylabs/channel-slack/transports/socket';
 import { SlackDirectAuthOptions, SlackDirectAuthMode } from '@cuylabs/channel-slack/auth';
-import { S as SlackAssistantBridge, C as CreateSlackAssistantBridgeOptions, b as SlackAssistantFeedbackConfig } from './options-CdqBABcM.js';
+import { S as SlackAssistantBridge, C as CreateSlackAssistantBridgeOptions, d as SlackAssistantFeedbackConfig } from './options-C7-VXmhD.js';
 import { SlackAgentAppSurfaceOptions } from './app-surface.js';
 import { SlackFeedbackHandler } from '@cuylabs/channel-slack/feedback';
 import '@cuylabs/agent-core';

package/dist/socket.js

@@ -1,9 +1,9 @@
 import {
   mountSlackAgentAppSocket,
   mountSlackAssistantAgentSocket
-} from "./chunk-VMVQIDNR.js";
-import "./chunk-7DUO5BMW.js";
-import "./chunk-MGBNGG4D.js";
+} from "./chunk-YSDFYHPC.js";
+import "./chunk-6T6N4MRK.js";
+import "./chunk-7YZWCSML.js";
 import "./chunk-ELR6MQD7.js";
 import "./chunk-FQWFB54C.js";
 import "./chunk-TMADMHBN.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cuylabs/channel-slack-agent-core",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "description": "Slack adapter for @cuylabs/agent-core built on @cuylabs/channel-slack",
   "type": "module",
   "main": "./dist/index.js",
@@ -94,7 +94,7 @@
   ],
   "dependencies": {
     "@cuylabs/agent-core": "^7.2.0",
-    "@cuylabs/channel-slack": "^0.7.0"
+    "@cuylabs/channel-slack": "^0.8.0"
   },
   "peerDependencies": {
     "@slack/bolt": ">=4.7.3",