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

package/dist/chunk-FJP6ZFUB.js

@@ -1,921 +0,0 @@
-import {
-  SLACK_FEEDBACK_ACTION_ID,
-  createSlackFeedbackBlock,
-  registerSlackFeedbackAction
-} from "./chunk-ELR6MQD7.js";
-import {
-  UnsupportedSlackInteractiveRequestError,
-  bridgeAgentEventsToSlack,
-  resolveSlackEventBridgeOptions
-} 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?";
-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-agent-core] 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-agent-core] 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-agent-core] 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-agent-core] 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-agent-core] threadContextChanged failed: ${error instanceof Error ? error.message : String(error)}`
-      );
-    }
-  };
-}
-
-// src/assistant/lifecycle/user-message.ts
-import {
-  withinScope
-} from "@cuylabs/agent-core";
-import {
-  extractSlackAuthContext,
-  resolveSlackMessageFormatter,
-  runWithSlackTurnContext
-} from "@cuylabs/channel-slack/core";
-import { parseSlackMessageActivityFromMessageEvent } from "@cuylabs/channel-slack/assistant";
-
-// 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/scope-attributes.ts
-function buildAssistantScopeAttributes(message, auth, threadContext, prep) {
-  return {
-    slackChannelId: message.channelId,
-    slackChannelType: message.channelType,
-    slackUserId: message.userId,
-    slackTeamId: message.teamId ?? auth.teamId,
-    slackEnterpriseId: auth.enterpriseId,
-    slackThreadTs: message.threadTs,
-    slackMessageTs: message.messageTs,
-    slackAssistantOriginChannelId: threadContext.channel_id,
-    ...prep.scopeAttributes ?? {}
-  };
-}
-
-// 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 } : {}
-        },
-        () => withinScope(
-          {
-            kind: "activity",
-            name: turnPrep.scopeName?.trim() || "slack-assistant-activity",
-            sessionId,
-            attributes: buildAssistantScopeAttributes(
-              parsed,
-              auth,
-              threadContext,
-              turnPrep
-            )
-          },
-          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 bridgeAgentEventsToSlack(
-              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-agent-core] userMessage error surfaced to user: ${translatedError.message}`
-        );
-      }
-    }
-  };
-}
-
-// 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) {
-  if (!options.source || typeof options.source.chat !== "function") {
-    throw new Error(
-      "createSlackAssistantBridge: options.source must implement AgentTurnSource"
-    );
-  }
-  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 ? resolveSlackTurnCancelActionId2(
-    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;
-}
-
-// src/assistant/index.ts
-import {
-  createSlackAssistantThreadContextStore as createSlackAssistantThreadContextStore2,
-  parseSlackMessageActivityFromMessageEvent as parseSlackMessageActivityFromMessageEvent2
-} from "@cuylabs/channel-slack/assistant";
-
-export {
-  resolveAssistantSessionId,
-  createSlackAssistantBridge,
-  createSlackAssistantThreadContextStore2 as createSlackAssistantThreadContextStore,
-  parseSlackMessageActivityFromMessageEvent2 as parseSlackMessageActivityFromMessageEvent
-};