@cuylabs/channel-slack 0.10.0 → 0.12.0

package/dist/chunk-Q6YX7HHK.js

@@ -0,0 +1,1062 @@
+import {
+  SLACK_FEEDBACK_ACTION_ID,
+  createSlackFeedbackBlock,
+  registerSlackFeedbackAction
+} from "./chunk-RHOIVQLD.js";
+import {
+  UnsupportedSlackInteractiveRequestError,
+  bridgeSlackTurnEventsToSlack,
+  resolveSlackEventBridgeOptions
+} from "./chunk-IAQXQESO.js";
+import {
+  extractSlackActionToken,
+  extractSlackAuthContext,
+  runWithSlackTurnContext
+} from "./chunk-37RN2YUI.js";
+import {
+  createSlackTurnCancelMessage,
+  registerSlackTurnCancelAction,
+  resolveSlackTurnCancelActionId
+} from "./chunk-3KP3CBCC.js";
+import {
+  resolveSlackChannelType,
+  stripLeadingMentions
+} from "./chunk-FPCE5V5Y.js";
+import {
+  resolveSlackMessageFormatter
+} from "./chunk-6WHFQUYQ.js";
+
+// src/assistant/thread-context-store.ts
+var ASSISTANT_THREAD_CONTEXT_EVENT_TYPE = "assistant_thread_context";
+function createSlackAssistantThreadContextStore() {
+  const cache = /* @__PURE__ */ new Map();
+  return {
+    async get(args) {
+      args.logger?.debug?.("[channel-slack] thread context store get called");
+      const { channelId, threadTs } = extractThreadInfo(args.payload);
+      const cacheKey = contextCacheKey(channelId, threadTs);
+      const cached = cache.get(cacheKey);
+      if (cached) return cached;
+      const messages = await readThreadMessages(args, channelId, threadTs);
+      const botUserId = args.context?.botUserId;
+      const metadataMessage = findContextMessage(messages, botUserId);
+      const context = toThreadContext(metadataMessage?.metadata?.event_payload);
+      cache.set(cacheKey, context);
+      return context;
+    },
+    async save(args) {
+      args.logger?.debug?.("[channel-slack] thread context store save called");
+      const { channelId, threadTs, context } = extractThreadInfo(args.payload);
+      const cacheKey = contextCacheKey(channelId, threadTs);
+      cache.set(cacheKey, context);
+      const messages = await readThreadMessages(args, channelId, threadTs);
+      const initialMessage = findInitialBotMessage(
+        messages,
+        args.context?.botUserId
+      );
+      if (!initialMessage?.ts) return;
+      await args.client?.chat?.update?.({
+        channel: channelId,
+        ts: initialMessage.ts,
+        text: initialMessage.text ?? "",
+        blocks: Array.isArray(initialMessage.blocks) ? initialMessage.blocks : [],
+        metadata: {
+          event_type: ASSISTANT_THREAD_CONTEXT_EVENT_TYPE,
+          event_payload: context
+        }
+      });
+    }
+  };
+}
+async function readThreadMessages(args, channelId, threadTs) {
+  const replies = args.client?.conversations?.replies;
+  if (typeof replies !== "function") return [];
+  const result = await replies({
+    channel: channelId,
+    ts: threadTs,
+    oldest: threadTs,
+    include_all_metadata: true,
+    limit: 4
+  });
+  return Array.isArray(result.messages) ? result.messages.filter(isSlackMessageWithMetadata) : [];
+}
+function findContextMessage(messages, botUserId) {
+  return messages.find(
+    (message) => isBotAuthoredMessage(message, botUserId) && message.metadata?.event_type === ASSISTANT_THREAD_CONTEXT_EVENT_TYPE
+  ) ?? messages.find(
+    (message) => isBotAuthoredMessage(message, botUserId) && message.metadata?.event_payload
+  );
+}
+function findInitialBotMessage(messages, botUserId) {
+  return messages.find((message) => isBotAuthoredMessage(message, botUserId));
+}
+function isBotAuthoredMessage(message, botUserId) {
+  if (message.subtype) return false;
+  return botUserId ? message.user === botUserId : Boolean(message.user);
+}
+function extractThreadInfo(payload) {
+  const channelId = extractChannelId(payload);
+  const threadTs = extractThreadTs(payload);
+  if (!channelId || !threadTs) {
+    const missing = [];
+    if (!channelId) missing.push("channel_id");
+    if (!threadTs) missing.push("thread_ts");
+    throw new Error(
+      `Assistant payload is missing required properties: ${missing.join(", ")}`
+    );
+  }
+  return {
+    channelId,
+    threadTs,
+    context: extractThreadContext(payload)
+  };
+}
+function extractThreadContext(payload) {
+  if (!isRecord(payload)) return {};
+  const assistantThread = payload.assistant_thread;
+  if (!isRecord(assistantThread) || !isRecord(assistantThread.context)) {
+    return {};
+  }
+  return toThreadContext(assistantThread.context);
+}
+function extractThreadTs(payload) {
+  if (!isRecord(payload)) return void 0;
+  if (isNonEmptyString(payload.thread_ts)) return payload.thread_ts;
+  if (isRecord(payload.assistant_thread) && isNonEmptyString(payload.assistant_thread.thread_ts)) {
+    return payload.assistant_thread.thread_ts;
+  }
+  if (isRecord(payload.message) && isNonEmptyString(payload.message.thread_ts)) {
+    return payload.message.thread_ts;
+  }
+  if (isRecord(payload.previous_message) && isNonEmptyString(payload.previous_message.thread_ts)) {
+    return payload.previous_message.thread_ts;
+  }
+  return void 0;
+}
+function extractChannelId(payload) {
+  if (!isRecord(payload)) return void 0;
+  if (isNonEmptyString(payload.channel)) return payload.channel;
+  if (isRecord(payload.channel) && isNonEmptyString(payload.channel.id)) {
+    return payload.channel.id;
+  }
+  if (isNonEmptyString(payload.channel_id)) return payload.channel_id;
+  if (isRecord(payload.item) && isNonEmptyString(payload.item.channel)) {
+    return payload.item.channel;
+  }
+  if (isRecord(payload.assistant_thread) && isNonEmptyString(payload.assistant_thread.channel_id)) {
+    return payload.assistant_thread.channel_id;
+  }
+  return void 0;
+}
+function toThreadContext(value) {
+  if (!isRecord(value)) return {};
+  return {
+    ...isNonEmptyString(value.channel_id) ? { channel_id: value.channel_id } : {},
+    ...isNonEmptyString(value.team_id) ? { team_id: value.team_id } : {},
+    ..."enterprise_id" in value ? {
+      enterprise_id: typeof value.enterprise_id === "string" ? value.enterprise_id : null
+    } : {}
+  };
+}
+function isSlackMessageWithMetadata(value) {
+  return isRecord(value);
+}
+function contextCacheKey(channelId, threadTs) {
+  return `${channelId}:${threadTs}`;
+}
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.length > 0;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+
+// src/assistant/message-parser.ts
+function parseSlackMessageActivityFromMessageEvent(message) {
+  if (!message || typeof message !== "object") return void 0;
+  const m = message;
+  if (m.subtype && m.subtype.length > 0) return void 0;
+  if (typeof m.text !== "string" || m.text.length === 0) return void 0;
+  if (typeof m.thread_ts !== "string" || m.thread_ts.length === 0) {
+    return void 0;
+  }
+  const channel = typeof m.channel === "string" ? m.channel : void 0;
+  if (!channel) return void 0;
+  const threadTs = m.thread_ts;
+  const messageTs = m.ts;
+  const isThread = threadTs !== messageTs;
+  const channelType = resolveSlackChannelType(channel, threadTs, isThread);
+  const rawText = m.text;
+  const text = channelType === "dm" ? rawText.trim() : stripLeadingMentions(rawText);
+  return {
+    channel,
+    threadTs,
+    channelId: channel,
+    channelType,
+    userId: m.user ?? "unknown",
+    teamId: m.team ?? void 0,
+    parentUserId: m.parent_user_id,
+    actionToken: extractSlackActionToken(m),
+    text,
+    isMention: false,
+    ...messageTs ? { messageTs } : {}
+  };
+}
+
+// src/assistant/bridge.ts
+import { Assistant } from "@slack/bolt";
+
+// src/assistant/options.ts
+var DEFAULT_INITIAL_REPLY = "Hi, how can I help?";
+var DEFAULT_INITIAL_STATUS = {
+  status: "Thinking..."
+};
+var DEFAULT_STREAM_ERROR_MESSAGE = "I ran into an error while preparing this answer. Please try again.";
+
+// src/assistant/helpers.ts
+function toError(value) {
+  return value instanceof Error ? value : new Error(String(value));
+}
+function formatErrorForLog(error) {
+  if (error instanceof Error) {
+    return error.stack ?? error.message;
+  }
+  return String(error);
+}
+async function safeGetThreadContext(getThreadContext, logger) {
+  try {
+    const value = await getThreadContext();
+    if (value && typeof value === "object") {
+      return value;
+    }
+  } catch (error) {
+    logger.warn?.("getThreadContext failed", {
+      error: formatErrorForLog(error)
+    });
+  }
+  return {};
+}
+async function resolveInitialReply(resolver, context) {
+  if (resolver === void 0) {
+    return DEFAULT_INITIAL_REPLY;
+  }
+  const value = await resolver(context);
+  if (value === false) {
+    return void 0;
+  }
+  return value ?? void 0;
+}
+async function resolveInitialStatus(resolver, request) {
+  if (resolver === void 0) {
+    return DEFAULT_INITIAL_STATUS;
+  }
+  if (typeof resolver === "function") {
+    return await resolver(request) ?? void 0;
+  }
+  return resolver;
+}
+async function resolveStatusUpdate(resolver, label, event, rawArgs) {
+  if (!resolver) {
+    return label ? { status: label } : { status: "" };
+  }
+  if (!event) {
+    return void 0;
+  }
+  return await resolver({ event, rawArgs }) ?? void 0;
+}
+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}`;
+  }
+}
+
+// src/assistant/lifecycle/thread-started.ts
+function createThreadStartedHandler(options) {
+  return async (args) => {
+    const {
+      event,
+      context,
+      client,
+      logger,
+      say,
+      setSuggestedPrompts,
+      saveThreadContext
+    } = args;
+    const threadCtx = {
+      event,
+      context,
+      client,
+      logger
+    };
+    let savedThreadContext = false;
+    const saveContext = async () => {
+      if (savedThreadContext) return;
+      try {
+        await saveThreadContext();
+        savedThreadContext = true;
+      } catch (error) {
+        logger.error(
+          `[channel-slack] saveThreadContext failed: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    };
+    try {
+      const initialReply = await resolveInitialReply(
+        options.getInitialReply,
+        threadCtx
+      );
+      if (initialReply) {
+        await say(initialReply);
+      }
+    } catch (error) {
+      logger.error(
+        `[channel-slack] initial assistant reply failed: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+    await saveContext();
+    try {
+      const prompts = await options.getSuggestedPrompts?.(threadCtx);
+      if (prompts && prompts.prompts.length > 0) {
+        await setSuggestedPrompts({
+          ...prompts.title ? { title: prompts.title } : {},
+          prompts: prompts.prompts
+        });
+      }
+    } catch (error) {
+      logger.error(
+        `[channel-slack] setSuggestedPrompts failed: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  };
+}
+
+// src/assistant/lifecycle/thread-context-changed.ts
+function createThreadContextChangedHandler() {
+  return async ({ event, saveThreadContext, logger }) => {
+    try {
+      await saveThreadContext();
+      logger.info("[channel-slack] thread context changed saved", {
+        channelId: event.assistant_thread.channel_id,
+        threadTs: event.assistant_thread.thread_ts,
+        originChannelId: event.assistant_thread.context.channel_id,
+        teamId: event.assistant_thread.context.team_id
+      });
+    } catch (error) {
+      logger.error(
+        `[channel-slack] threadContextChanged failed: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  };
+}
+
+// src/assistant/session.ts
+function resolveAssistantSessionId(message, strategy) {
+  switch (strategy) {
+    case "channel-id":
+      return message.channel;
+    case "user-per-thread":
+      return `${message.channel}:${message.threadTs}:${message.userId}`;
+    default:
+      return `${message.channel}:${message.threadTs}`;
+  }
+}
+
+// src/assistant/sink.ts
+function createAssistantSink(params) {
+  let stream;
+  let stopped = false;
+  function ensureStream(bufferSize) {
+    if (stream) return stream;
+    const streamArgs = {
+      ...params.chatStreamStartArgs ?? {},
+      task_display_mode: params.taskDisplayMode,
+      buffer_size: bufferSize
+    };
+    let created;
+    if (typeof params.sayStream === "function") {
+      created = params.sayStream(streamArgs);
+    } else {
+      const clientWithStream = params.client;
+      if (typeof clientWithStream.chatStream !== "function") {
+        throw new Error(
+          "Slack client does not expose chatStream; ensure @slack/web-api >=7.16.0 is installed."
+        );
+      }
+      created = clientWithStream.chatStream({
+        channel: params.channel,
+        thread_ts: params.threadTs,
+        ...params.teamId ? { recipient_team_id: params.teamId } : {},
+        ...params.userId ? { recipient_user_id: params.userId } : {},
+        ...streamArgs
+      });
+    }
+    stream = {
+      append: (args) => created.append(args),
+      stop: async (args) => {
+        if (stopped) return void 0;
+        stopped = true;
+        return created.stop(args);
+      }
+    };
+    return stream;
+  }
+  return {
+    artifactClient: params.client,
+    artifactTarget: {
+      channelId: params.channel,
+      threadTs: params.threadTs
+    },
+    async postMessage() {
+      throw new Error(
+        "Assistant bridge uses chat-stream mode and does not support postMessage."
+      );
+    },
+    async updateMessage() {
+    },
+    createChatStream: ({ bufferSize }) => ensureStream(bufferSize),
+    async appendError(text) {
+      if (stopped) return;
+      const target = ensureStream(256);
+      await target.append({ markdown_text: `
+
+${text}` });
+    },
+    async finalize() {
+      if (stopped || !stream) return;
+      await stream.stop();
+    }
+  };
+}
+function createAssistantInteractiveResponder(params) {
+  return {
+    async postMessage(message) {
+      const result = await params.client.chat.postMessage({
+        channel: params.channel,
+        thread_ts: params.threadTs,
+        text: message.text,
+        ...message.blocks ? { blocks: message.blocks } : {}
+      });
+      if (!result.channel || !result.ts) {
+        throw new Error(
+          "Slack chat.postMessage response did not include channel and ts."
+        );
+      }
+      return { channel: result.channel, ts: result.ts };
+    },
+    async updateMessage(ref, message) {
+      await params.client.chat.update({
+        channel: ref.channel,
+        ts: ref.ts,
+        text: message.text,
+        ...message.blocks ? { blocks: message.blocks } : {}
+      });
+    }
+  };
+}
+
+// src/assistant/lifecycle/user-message.ts
+function createUserMessageHandler(deps) {
+  const { options, feedbackBlock, sessionStrategy, turnControlController } = deps;
+  const taskDisplayMode = options.taskDisplayMode ?? "timeline";
+  const messageFormatter = resolveSlackMessageFormatter(
+    options.formatChatMarkdown ?? {}
+  );
+  const formatStreamError = options.formatStreamError ?? (() => DEFAULT_STREAM_ERROR_MESSAGE);
+  const showReasoning = options.showReasoning ?? false;
+  const showToolUsage = options.showToolUsage ?? true;
+  const showSubagentToolUsage = options.showSubagentToolUsage ?? false;
+  const showSubagentResultInTask = options.showSubagentResultInTask ?? false;
+  const timeoutMs = options.timeoutMs ?? 12e4;
+  return async (args) => {
+    const {
+      message,
+      client,
+      context,
+      logger,
+      sayStream,
+      setStatus,
+      setSuggestedPrompts,
+      setTitle,
+      getThreadContext,
+      saveThreadContext
+    } = args;
+    const parsed = parseSlackMessageActivityFromMessageEvent(message);
+    if (!parsed) {
+      return;
+    }
+    const { channel, threadTs, text, userId } = parsed;
+    const teamId = context.teamId ?? context.enterpriseId;
+    if (!channel || !threadTs || !text) {
+      return;
+    }
+    const diagnosticsLogger = options.logger ?? logger;
+    const auth = extractSlackAuthContext(context, userId);
+    const threadContext = await safeGetThreadContext(
+      getThreadContext,
+      diagnosticsLogger
+    );
+    const assistantUtilities = {
+      setStatus: async (update) => {
+        await setStatus(update);
+      },
+      setSuggestedPrompts: async (prompts) => {
+        await setSuggestedPrompts({
+          ...prompts.title ? { title: prompts.title } : {},
+          prompts: prompts.prompts
+        });
+      },
+      setTitle: async (title) => {
+        await setTitle(title);
+      },
+      getThreadContext: () => getThreadContext(),
+      saveThreadContext: () => saveThreadContext()
+    };
+    const initialSessionId = resolveAssistantSessionId(parsed, sessionStrategy);
+    const baseRequest = {
+      message: parsed,
+      sessionId: initialSessionId,
+      client,
+      rawArgs: args,
+      auth,
+      threadContext,
+      assistant: assistantUtilities
+    };
+    const sink = createAssistantSink({
+      client,
+      sayStream,
+      channel,
+      threadTs,
+      teamId,
+      userId,
+      taskDisplayMode,
+      ...options.chatStreamStartArgs ? { chatStreamStartArgs: options.chatStreamStartArgs } : {}
+    });
+    let translatedError;
+    let unsupportedInteractive;
+    let timeoutId;
+    try {
+      const initialStatus = await resolveInitialStatus(
+        options.initialStatus,
+        baseRequest
+      );
+      if (initialStatus) {
+        try {
+          await setStatus(initialStatus);
+        } catch (error) {
+          diagnosticsLogger.warn?.("setStatus failed", {
+            error: formatErrorForLog(error)
+          });
+        }
+      }
+      let sessionId = initialSessionId;
+      if (options.resolveSession) {
+        const resolved = await options.resolveSession(baseRequest);
+        if (resolved && resolved.length > 0) {
+          sessionId = resolved;
+        }
+      }
+      const turnPrep = await options.prepareTurn?.({ ...baseRequest, sessionId }) ?? {};
+      if (turnPrep.sessionId && turnPrep.sessionId.length > 0) {
+        sessionId = turnPrep.sessionId;
+      }
+      const turnMessage = turnPrep.message ?? text;
+      const userMessageRequest = {
+        ...baseRequest,
+        sessionId,
+        message: { ...parsed, text: turnMessage }
+      };
+      if (options.formatThreadTitle) {
+        try {
+          const title = await options.formatThreadTitle(userMessageRequest);
+          if (title) {
+            await setTitle(title);
+          }
+        } catch (error) {
+          diagnosticsLogger.warn?.("setTitle failed", {
+            error: formatErrorForLog(error)
+          });
+        }
+      }
+      const configuredFinalBlocks = Array.isArray(
+        options.chatStreamFinalArgs?.blocks
+      ) ? options.chatStreamFinalArgs.blocks : [];
+      const finalBlocks = feedbackBlock ? [...configuredFinalBlocks, feedbackBlock] : configuredFinalBlocks;
+      const chatStreamFinalArgs = options.chatStreamFinalArgs || finalBlocks.length > 0 ? {
+        ...options.chatStreamFinalArgs ?? {},
+        ...finalBlocks.length > 0 ? { blocks: finalBlocks } : {}
+      } : void 0;
+      const bridgeOptions = resolveSlackEventBridgeOptions({
+        streamingMode: "chat-stream",
+        showReasoning,
+        showToolUsage,
+        showSubagentToolUsage,
+        showSubagentResultInTask,
+        ...options.formatToolTitle ? { formatToolTitle: options.formatToolTitle } : {},
+        ...options.formatToolUpdate ? { formatToolUpdate: options.formatToolUpdate } : {},
+        ...options.formatToolDetails ? { formatToolDetails: options.formatToolDetails } : {},
+        ...options.formatToolResultOutput ? { formatToolResultOutput: options.formatToolResultOutput } : {},
+        ...options.formatToolError ? { formatToolError: options.formatToolError } : {},
+        ...options.formatReasoningUpdate ? { formatReasoningUpdate: options.formatReasoningUpdate } : {},
+        ...options.chatStreamBufferSize !== void 0 ? { chatStreamBufferSize: options.chatStreamBufferSize } : {},
+        ...options.maxTaskUpdates !== void 0 ? { maxTaskUpdates: options.maxTaskUpdates } : {},
+        ...options.maxTaskUpdateTextChars !== void 0 ? { maxTaskUpdateTextChars: options.maxTaskUpdateTextChars } : {},
+        ...options.maxTaskUpdateFieldChars !== void 0 ? { maxTaskUpdateFieldChars: options.maxTaskUpdateFieldChars } : {},
+        ...chatStreamFinalArgs ? { chatStreamFinalArgs } : {},
+        ...options.publishFinalResponseArtifact ? {
+          publishFinalResponseArtifact: options.publishFinalResponseArtifact
+        } : {},
+        ...options.finalResponseArtifactMode ? { finalResponseArtifactMode: options.finalResponseArtifactMode } : {},
+        ...options.finalResponseArtifactStreamThreshold !== void 0 ? {
+          finalResponseArtifactStreamThreshold: options.finalResponseArtifactStreamThreshold
+        } : {},
+        ...options.formatFinalResponseArtifactContinuationNotice ? {
+          formatFinalResponseArtifactContinuationNotice: options.formatFinalResponseArtifactContinuationNotice
+        } : {},
+        ...options.formatFinalResponseArtifactMessage ? {
+          formatFinalResponseArtifactMessage: options.formatFinalResponseArtifactMessage
+        } : {},
+        ...options.onFinalResponseArtifactError ? {
+          onFinalResponseArtifactError: options.onFinalResponseArtifactError
+        } : {},
+        formatMessageText: messageFormatter,
+        onStatusChange: async (label, event) => {
+          const update = await resolveStatusUpdate(
+            options.formatStatus,
+            label,
+            event,
+            args
+          );
+          if (update) {
+            try {
+              await setStatus(update);
+            } catch (error) {
+              diagnosticsLogger.warn?.("setStatus failed", {
+                error: formatErrorForLog(error)
+              });
+            }
+          }
+        },
+        ...options.handleInteractiveRequest ? {
+          handleInteractiveRequest: (interactive) => options.handleInteractiveRequest({
+            ...interactive,
+            slackActivity: parsed,
+            user: {
+              userId: userId ?? "unknown",
+              channelId: channel,
+              ...teamId ? { teamId } : {},
+              threadTs,
+              ...parsed.messageTs ? { messageTs: parsed.messageTs } : {}
+            },
+            sessionId,
+            message: turnMessage,
+            responder: createAssistantInteractiveResponder({
+              client,
+              channel,
+              threadTs
+            })
+          })
+        } : {}
+      });
+      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,
+          user: {
+            userId: userId ?? "unknown",
+            channelId: channel,
+            ...teamId ? { teamId } : {},
+            threadTs
+          },
+          sessionId,
+          message: turnMessage,
+          auth,
+          threadContext,
+          assistant: assistantUtilities,
+          ...turnPrep.context ? { context: turnPrep.context } : {}
+        },
+        async () => {
+          const events = options.source.chat(sessionId, turnMessage, {
+            abort: abortController.signal,
+            ...turnPrep.system ? { system: turnPrep.system } : {}
+          });
+          const translated = (async function* () {
+            try {
+              for await (const event of events) {
+                cancelControl?.sync(event);
+                if (event.type === "error") {
+                  translatedError = toError(
+                    event.error
+                  );
+                  yield {
+                    type: "text-delta",
+                    text: `
+
+${formatStreamError(translatedError)}`
+                  };
+                  yield { type: "complete" };
+                  return;
+                }
+                yield event;
+              }
+            } catch (error) {
+              if (error instanceof UnsupportedSlackInteractiveRequestError) {
+                unsupportedInteractive = error;
+                throw error;
+              }
+              translatedError = toError(error);
+              yield {
+                type: "text-delta",
+                text: `
+
+${formatStreamError(translatedError)}`
+              };
+              yield { type: "complete" };
+            } finally {
+              cancelControl?.clear("turn-finished");
+            }
+          })();
+          const finalText = await bridgeSlackTurnEventsToSlack(
+            translated,
+            sink,
+            bridgeOptions
+          );
+          if (!translatedError && options.getFollowUpPrompts) {
+            try {
+              const followUps = await options.getFollowUpPrompts({
+                ...userMessageRequest,
+                finalText
+              });
+              if (followUps && followUps.prompts.length > 0) {
+                await assistantUtilities.setSuggestedPrompts(followUps);
+              }
+            } catch (error) {
+              diagnosticsLogger.warn?.("getFollowUpPrompts failed", {
+                error: formatErrorForLog(error)
+              });
+            }
+          }
+        }
+      );
+    } catch (error) {
+      if (error instanceof UnsupportedSlackInteractiveRequestError && !unsupportedInteractive) {
+        unsupportedInteractive = error;
+      }
+      if (!unsupportedInteractive) {
+        try {
+          await sink.appendError(formatStreamError(toError(error)));
+        } catch {
+        }
+      }
+      try {
+        await sink.finalize();
+      } catch {
+      }
+    } finally {
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+      }
+      try {
+        await setStatus({ status: "" });
+      } catch {
+      }
+      if (translatedError) {
+        logger.error(
+          `[channel-slack] userMessage error surfaced to user: ${translatedError.message}`
+        );
+      }
+    }
+  };
+}
+
+// src/assistant/turn-controls.ts
+import { randomUUID } from "crypto";
+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-end":
+      case "tool-start":
+      case "approval-request":
+      case "human-input-request":
+        showCancelControl(control, event.type);
+        break;
+      case "status":
+        if (isWaitingForSlackStatus(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 isWaitingForSlackStatus(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
+function createSlackAssistantBridge(options) {
+  if (!options.source || typeof options.source.chat !== "function") {
+    throw new Error(
+      "createSlackAssistantBridge: options.source must implement SlackTurnSource"
+    );
+  }
+  if (options.timeoutMs !== void 0 && (!Number.isFinite(options.timeoutMs) || options.timeoutMs < 0)) {
+    throw new Error(
+      "createSlackAssistantBridge: timeoutMs must be a finite non-negative number"
+    );
+  }
+  const sessionStrategy = options.sessionStrategy ?? "thread-aware";
+  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 ? resolveSlackTurnCancelActionId(
+    resolveTurnCancelActionIdOption(options.turnControls)
+  ) : void 0;
+  const threadStarted = createThreadStartedHandler(options);
+  const threadContextChanged = createThreadContextChangedHandler();
+  const threadContextStore = options.threadContextStore ?? createSlackAssistantThreadContextStore();
+  const userMessage = createUserMessageHandler({
+    options,
+    feedbackBlock,
+    sessionStrategy,
+    ...turnControlController ? { turnControlController } : {}
+  });
+  const config = {
+    threadStarted,
+    threadContextChanged,
+    userMessage,
+    // The store shape must match Bolt's `AssistantThreadContextStore` exactly.
+    // We accept the structural alias above and cast here so callers don't
+    // need to import Bolt's internal types in their own code.
+    threadContextStore
+  };
+  const assistant = new Assistant(config);
+  function install(app) {
+    app.assistant(assistant);
+    if (feedbackConfig) {
+      registerSlackFeedbackAction(app, {
+        ...feedbackConfig,
+        resolveSessionId: (context) => resolveFeedbackSessionId(context, sessionStrategy),
+        onFeedback: feedbackConfig.onFeedback ?? (async (_ctx) => {
+        })
+      });
+    }
+    turnControlController?.install(app);
+  }
+  return {
+    assistant,
+    install,
+    ...feedbackConfig ? { feedbackActionId } : {},
+    ...turnCancelActionId ? { turnCancelActionId } : {}
+  };
+}
+function resolveTurnCancelActionIdOption(options) {
+  if (!options || !options.cancel) {
+    return void 0;
+  }
+  return typeof options.cancel === "object" ? options.cancel.actionId : void 0;
+}
+
+export {
+  createSlackAssistantThreadContextStore,
+  parseSlackMessageActivityFromMessageEvent,
+  resolveAssistantSessionId,
+  createSlackAssistantBridge
+};