@cuylabs/channel-slack 0.9.0 → 0.11.0

package/dist/chunk-RHOIVQLD.js

@@ -0,0 +1,127 @@
+import {
+  openSlackModal
+} from "./chunk-IRFKUPJN.js";
+
+// src/feedback/block.ts
+var SLACK_FEEDBACK_ACTION_ID = "agent_feedback";
+function createSlackFeedbackBlock(options = {}) {
+  const actionId = (options.actionId ?? SLACK_FEEDBACK_ACTION_ID).trim();
+  if (!actionId) {
+    throw new Error(
+      "createSlackFeedbackBlock: actionId must be a non-empty string"
+    );
+  }
+  const positiveValue = options.positiveValue ?? "good-feedback";
+  const negativeValue = options.negativeValue ?? "bad-feedback";
+  const positiveLabel = options.positiveButton?.text ?? "Good Response";
+  const negativeLabel = options.negativeButton?.text ?? "Bad Response";
+  const positiveA11y = options.positiveButton?.accessibilityLabel ?? "Submit positive feedback on this response";
+  const negativeA11y = options.negativeButton?.accessibilityLabel ?? "Submit negative feedback on this response";
+  return {
+    type: "context_actions",
+    elements: [
+      {
+        type: "feedback_buttons",
+        action_id: actionId,
+        positive_button: {
+          text: { type: "plain_text", text: positiveLabel },
+          accessibility_label: positiveA11y,
+          value: positiveValue
+        },
+        negative_button: {
+          text: { type: "plain_text", text: negativeLabel },
+          accessibility_label: negativeA11y,
+          value: negativeValue
+        }
+      }
+    ]
+  };
+}
+
+// src/feedback/action.ts
+function registerSlackFeedbackAction(app, options) {
+  const actionId = (options.actionId ?? SLACK_FEEDBACK_ACTION_ID).trim();
+  const positiveValue = options.positiveValue ?? "good-feedback";
+  const negativeValue = options.negativeValue ?? "bad-feedback";
+  const positiveAck = options.positiveAck === void 0 ? "Thanks for the feedback!" : options.positiveAck;
+  const negativeAck = options.negativeAck === void 0 ? "Thanks \u2014 we'll use this to improve the assistant." : options.negativeAck;
+  app.action(
+    actionId,
+    // Bolt's action args don't have a single shared exported type; the
+    // structural shape we read here (ack/body/client/logger) is stable.
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    async ({ ack, body, client, logger }) => {
+      const ackFn = ack;
+      await ackFn();
+      try {
+        if (body?.type !== "block_actions" || !Array.isArray(body.actions) || body.actions.length === 0) {
+          return;
+        }
+        const action = body.actions[0];
+        if (action?.type !== "feedback_buttons") {
+          return;
+        }
+        const value = String(action.value ?? "");
+        const verdict = value === positiveValue ? "positive" : value === negativeValue ? "negative" : void 0;
+        if (!verdict) {
+          return;
+        }
+        const channelId = body.channel?.id ?? body.container?.channel_id;
+        const userId = body.user?.id;
+        const messageTs = body.message?.ts ?? body.container?.message_ts;
+        const threadTs = body.message?.thread_ts ?? body.container?.thread_ts;
+        const triggerId = typeof body.trigger_id === "string" ? body.trigger_id : void 0;
+        if (!channelId || !userId || !messageTs) {
+          return;
+        }
+        const openModal = async (view) => {
+          if (!triggerId) {
+            throw new Error(
+              "Slack feedback payload did not include trigger_id."
+            );
+          }
+          await openSlackModal({ client, triggerId, view });
+        };
+        const acknowledgeEphemeral = async (text) => {
+          await client.chat.postEphemeral({
+            channel: channelId,
+            user: userId,
+            ...threadTs ? { thread_ts: threadTs } : { thread_ts: messageTs },
+            text
+          });
+        };
+        const feedbackContext = {
+          verdict,
+          value,
+          channelId,
+          userId,
+          messageTs,
+          ...threadTs ? { threadTs } : {},
+          ...triggerId ? { triggerId } : {}
+        };
+        const sessionId = options.resolveSessionId?.(feedbackContext);
+        await options.onFeedback({
+          ...feedbackContext,
+          ...sessionId ? { sessionId } : {},
+          openModal,
+          acknowledgeEphemeral
+        });
+        const ackText = verdict === "positive" ? positiveAck : negativeAck;
+        if (ackText) {
+          await acknowledgeEphemeral(ackText);
+        }
+      } catch (error) {
+        logger?.error?.(
+          `[channel-slack] feedback handler failed: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  return { actionId, positiveValue, negativeValue };
+}
+
+export {
+  SLACK_FEEDBACK_ACTION_ID,
+  createSlackFeedbackBlock,
+  registerSlackFeedbackAction
+};

package/dist/chunk-RTDLIYEE.js

@@ -0,0 +1,446 @@
+import {
+  UnsupportedSlackInteractiveRequestError,
+  bridgeSlackTurnEventsToSlack,
+  resolveSlackEventBridgeOptions
+} from "./chunk-IAQXQESO.js";
+import {
+  extractSlackAuthContext,
+  extractSlackUserIdentity,
+  parseSlackMentionActivity,
+  parseSlackMessageActivity,
+  resolveThreadAwareSlackSessionId,
+  runWithSlackTurnContext
+} from "./chunk-37RN2YUI.js";
+import {
+  isProcessableMessage
+} from "./chunk-FPCE5V5Y.js";
+import {
+  resolveSlackMessageFormatter
+} from "./chunk-6WHFQUYQ.js";
+
+// src/adapter/session-map.ts
+function createSlackSessionMap(options) {
+  const strategy = options.sessionStrategy ?? "thread-aware";
+  if (strategy === "custom") {
+    if (!options.resolveSessionId) {
+      throw new Error(
+        "SlackChannelOptions.resolveSessionId is required when sessionStrategy is 'custom'"
+      );
+    }
+    const customResolve = options.resolveSessionId;
+    return {
+      resolve(info) {
+        return customResolve(info);
+      }
+    };
+  }
+  if (strategy === "channel-id") {
+    return {
+      resolve(info) {
+        return info.channelId;
+      }
+    };
+  }
+  if (strategy === "user-per-channel") {
+    return {
+      resolve(info) {
+        return `${info.channelId}:${info.userId}`;
+      }
+    };
+  }
+  if (strategy === "user-per-thread") {
+    return {
+      resolve(info) {
+        if (info.channelType === "dm") {
+          return `${info.channelId}:${info.userId}`;
+        }
+        return `${info.channelId}:${info.threadTs ?? info.messageTs ?? info.channelId}:${info.userId}`;
+      }
+    };
+  }
+  return {
+    resolve: resolveThreadAwareSlackSessionId
+  };
+}
+
+// src/adapter/sink.ts
+function buildThreadPayload(info, respondInThread) {
+  if (!respondInThread || info.channelType === "dm") return {};
+  const threadTs = info.threadTs ?? info.messageTs;
+  return threadTs ? { thread_ts: threadTs } : {};
+}
+function buildResponseSink(say, client, info, respondInThread, chatStreamStartArgs, sayStream) {
+  const threadPayload = buildThreadPayload(info, respondInThread);
+  return {
+    artifactClient: client,
+    artifactTarget: {
+      channelId: info.channelId,
+      ...threadPayload.thread_ts ? { threadTs: threadPayload.thread_ts } : {}
+    },
+    async postMessage(text) {
+      const result = await say({ text, ...threadPayload });
+      const response = result;
+      const { channel, ts } = response;
+      if (!channel || !ts) {
+        throw new Error("Slack say() response did not include channel and ts.");
+      }
+      return { channel, ts };
+    },
+    async updateMessage(channel, ts, text) {
+      await client.chat.update({ channel, ts, text });
+    },
+    createChatStream({ bufferSize }) {
+      const threadTs = threadPayload.thread_ts ?? info.messageTs;
+      if (!threadTs) {
+        throw new Error(
+          "Slack chat-stream mode requires a source message timestamp."
+        );
+      }
+      const streamArgs = {
+        ...chatStreamStartArgs ?? {},
+        buffer_size: bufferSize
+      };
+      if (typeof sayStream === "function") {
+        return sayStream(streamArgs);
+      }
+      const streamer = client.chatStream({
+        channel: info.channelId,
+        thread_ts: threadTs,
+        ...info.teamId ? { recipient_team_id: info.teamId } : {},
+        recipient_user_id: info.userId,
+        ...streamArgs
+      });
+      return streamer;
+    }
+  };
+}
+function buildInteractiveResponder(say, client, info, respondInThread) {
+  const threadPayload = buildThreadPayload(info, respondInThread);
+  return {
+    async postMessage(message) {
+      const result = await say({
+        text: message.text,
+        ...message.blocks ? { blocks: message.blocks } : {},
+        ...threadPayload
+      });
+      const response = result;
+      const channel = response.channel ?? info.channelId;
+      const ts = response.ts;
+      if (!channel || !ts) {
+        throw new Error("Slack say() response did not include channel and ts.");
+      }
+      return { channel, ts };
+    },
+    async updateMessage(ref, message) {
+      await client.chat.update({
+        channel: ref.channel,
+        ts: ref.ts,
+        text: message.text,
+        ...message.blocks ? { blocks: message.blocks } : {}
+      });
+    }
+  };
+}
+
+// src/adapter/adapter.ts
+var DEFAULT_CLASSIC_INITIAL_STATUS = {
+  status: "Thinking..."
+};
+function createSlackChannelAdapter(options) {
+  const { source } = options;
+  if (!source || typeof source.chat !== "function") {
+    throw new Error(
+      "createSlackChannelAdapter: options.source must implement SlackTurnSource."
+    );
+  }
+  const sessionMap = createSlackSessionMap(options);
+  const bridgeOptions = resolveSlackEventBridgeOptions(
+    {
+      showReasoning: options.showReasoning,
+      showToolUsage: options.showToolUsage,
+      showSubagentToolUsage: options.showSubagentToolUsage,
+      showSubagentResultInTask: options.showSubagentResultInTask,
+      formatToolTitle: options.formatToolTitle,
+      formatToolUpdate: options.formatToolUpdate,
+      formatToolDetails: options.formatToolDetails,
+      formatToolResultOutput: options.formatToolResultOutput,
+      formatToolError: options.formatToolError,
+      formatReasoningUpdate: options.formatReasoningUpdate,
+      interactiveMode: options.interactiveMode,
+      formatApprovalRequired: options.formatApprovalRequired,
+      formatHumanInputRequired: options.formatHumanInputRequired,
+      formatMessageText: resolveSlackMessageFormatter(options),
+      streamingMode: options.streamingMode,
+      progressiveUpdateThreshold: options.progressiveUpdateThreshold,
+      progressiveUpdateIntervalMs: options.progressiveUpdateIntervalMs,
+      chatStreamBufferSize: options.chatStreamBufferSize,
+      maxTaskUpdates: options.maxTaskUpdates,
+      maxTaskUpdateTextChars: options.maxTaskUpdateTextChars,
+      maxTaskUpdateFieldChars: options.maxTaskUpdateFieldChars,
+      chatStreamFinalArgs: options.chatStreamFinalArgs,
+      publishFinalResponseArtifact: options.publishFinalResponseArtifact,
+      finalResponseArtifactMode: options.finalResponseArtifactMode,
+      finalResponseArtifactStreamThreshold: options.finalResponseArtifactStreamThreshold,
+      formatFinalResponseArtifactContinuationNotice: options.formatFinalResponseArtifactContinuationNotice,
+      formatFinalResponseArtifactMessage: options.formatFinalResponseArtifactMessage,
+      onFinalResponseArtifactError: options.onFinalResponseArtifactError
+    }
+  );
+  const timeout = options.timeout ?? 12e4;
+  const respondInThread = options.respondInThread ?? true;
+  const respondToMentions = options.respondToMentions ?? true;
+  const respondToMessages = options.respondToMessages ?? true;
+  const respondToChannelMessages = options.respondToChannelMessages ?? false;
+  async function processTurn(slackActivity, say, client, context, utilities = {}) {
+    const rawText = slackActivity.text.trim();
+    const userText = options.resolveMessage ? await options.resolveMessage(slackActivity) : rawText;
+    if (!userText) return;
+    const initialSessionId = await sessionMap.resolve(slackActivity);
+    const userIdentity = extractSlackUserIdentity(slackActivity);
+    const auth = extractSlackAuthContext(context, slackActivity.userId);
+    const hasSayStream = typeof utilities.sayStream === "function";
+    const hasSetStatus = typeof utilities.setStatus === "function";
+    options.logger?.debug?.("slack classic turn utilities", {
+      channelId: slackActivity.channelId,
+      channelType: slackActivity.channelType,
+      isMention: slackActivity.isMention,
+      threadTs: slackActivity.threadTs,
+      messageTs: slackActivity.messageTs,
+      hasSayStream,
+      hasSetStatus
+    });
+    const baseTurnRequest = {
+      slackActivity,
+      user: userIdentity,
+      sessionId: initialSessionId,
+      message: userText,
+      auth,
+      ...utilities.setStatus ? { setStatus: utilities.setStatus } : {}
+    };
+    if (utilities.setStatus) {
+      const initialStatus = await resolveClassicInitialStatus(
+        options,
+        baseTurnRequest
+      );
+      if (initialStatus) {
+        try {
+          await utilities.setStatus(initialStatus);
+        } catch (error) {
+          options.logger?.warn?.("slack classic setStatus failed", {
+            error: formatErrorForLog(error)
+          });
+        }
+      }
+    }
+    const resolvedSessionId = await options.resolveSession?.(baseTurnRequest);
+    const sessionId = resolvedSessionId && resolvedSessionId.length > 0 ? resolvedSessionId : initialSessionId;
+    const turnRequest = {
+      ...baseTurnRequest,
+      sessionId
+    };
+    const preparedTurn = await resolveTurnPreparation(
+      options,
+      turnRequest,
+      userIdentity
+    );
+    const finalSessionId = preparedTurn.sessionId && preparedTurn.sessionId.length > 0 ? preparedTurn.sessionId : sessionId;
+    const finalUserText = preparedTurn.message ?? userText;
+    const sink = buildResponseSink(
+      say,
+      client,
+      slackActivity,
+      respondInThread,
+      options.chatStreamStartArgs,
+      utilities.sayStream
+    );
+    const abortController = new AbortController();
+    const chatOptions = {
+      abort: abortController.signal
+    };
+    if (preparedTurn.system) {
+      chatOptions.system = preparedTurn.system;
+    }
+    const timeoutId = timeout > 0 ? setTimeout(() => abortController.abort(), timeout) : void 0;
+    try {
+      await runWithSlackTurnContext(
+        {
+          ...turnRequest,
+          sessionId: finalSessionId,
+          message: finalUserText,
+          ...utilities.setStatus ? { setStatus: utilities.setStatus } : {},
+          ...preparedTurn.context ? { context: preparedTurn.context } : {}
+        },
+        async () => {
+          const events = source.chat(
+            finalSessionId,
+            finalUserText,
+            chatOptions
+          );
+          const baseTurnBridgeOptions = options.handleInteractiveRequest ? {
+            ...bridgeOptions,
+            handleInteractiveRequest: (interactive) => options.handleInteractiveRequest({
+              ...interactive,
+              slackActivity,
+              user: userIdentity,
+              sessionId: finalSessionId,
+              message: finalUserText,
+              responder: buildInteractiveResponder(
+                say,
+                client,
+                slackActivity,
+                respondInThread
+              )
+            })
+          } : bridgeOptions;
+          const turnBridgeOptions = withClassicStatusUpdates(
+            baseTurnBridgeOptions,
+            utilities.setStatus
+          );
+          await bridgeSlackTurnEventsToSlack(events, sink, turnBridgeOptions);
+        }
+      );
+    } catch (error) {
+      const errorInstance = error instanceof Error ? error : new Error(String(error));
+      if (!(errorInstance instanceof UnsupportedSlackInteractiveRequestError)) {
+        await say({
+          text: `I encountered an error while processing your request: ${errorInstance.message}`,
+          ...buildThreadPayload(slackActivity, respondInThread)
+        }).catch(() => void 0);
+      }
+      if (options.onError) {
+        await options.onError(errorInstance, slackActivity);
+      }
+    } finally {
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+      }
+      if (utilities.setStatus) {
+        await utilities.setStatus({ status: "" }).catch(
+          (error) => options.logger?.warn?.("slack classic clear status failed", {
+            error: formatErrorForLog(error)
+          })
+        );
+      }
+    }
+  }
+  function mount(app) {
+    if (respondToMessages) {
+      app.message(
+        async ({
+          message,
+          say,
+          client,
+          context,
+          sayStream,
+          setStatus
+        }) => {
+          const raw = message;
+          if (!isProcessableMessage(
+            raw
+          )) {
+            return;
+          }
+          const info = parseSlackMessageActivity(
+            raw
+          );
+          if (info.channelType !== "dm" && !respondToChannelMessages) {
+            return;
+          }
+          if (!info.text) return;
+          await processTurn(info, say, client, context, {
+            ...typeof sayStream === "function" ? { sayStream } : {},
+            ...typeof setStatus === "function" ? { setStatus } : {}
+          });
+        }
+      );
+    }
+    if (respondToMentions) {
+      app.event(
+        "app_mention",
+        async ({
+          event,
+          say,
+          client,
+          context,
+          sayStream,
+          setStatus
+        }) => {
+          const info = parseSlackMentionActivity(
+            event
+          );
+          if (!info.text) return;
+          await processTurn(info, say, client, context, {
+            ...typeof sayStream === "function" ? { sayStream } : {},
+            ...typeof setStatus === "function" ? { setStatus } : {}
+          });
+        }
+      );
+    }
+    if (options.welcomeMessage != null) {
+      app.event("member_joined_channel", async ({ event, client }) => {
+        const channelId = event.channel;
+        const userId = event.user;
+        const botInfo = await client.auth.test().catch(() => void 0);
+        if (botInfo?.user_id === userId) return;
+        await client.chat.postMessage({
+          channel: userId,
+          // DM the new member
+          text: options.welcomeMessage
+        }).catch(() => void 0);
+        await client.chat.postMessage({
+          channel: channelId,
+          text: options.welcomeMessage
+        }).catch(() => void 0);
+      });
+    }
+  }
+  return {
+    mount,
+    getSessionId: (info) => sessionMap.resolve(info)
+  };
+}
+function formatClassicSlackStatusUpdate(status) {
+  return { status };
+}
+async function resolveClassicInitialStatus(options, request) {
+  if (options.initialStatus === void 0) {
+    return DEFAULT_CLASSIC_INITIAL_STATUS;
+  }
+  if (typeof options.initialStatus === "function") {
+    return await options.initialStatus(request) ?? void 0;
+  }
+  return options.initialStatus;
+}
+function withClassicStatusUpdates(options, setStatus) {
+  if (!setStatus) {
+    return options;
+  }
+  return {
+    ...options,
+    onStatusChange: async (label, event) => {
+      await options.onStatusChange?.(label, event);
+      await setStatus(formatClassicSlackStatusUpdate(label));
+    }
+  };
+}
+async function resolveTurnPreparation(options, request, user) {
+  if (options.prepareTurn) {
+    return await options.prepareTurn(request) ?? {};
+  }
+  if (options.resolveUserContext) {
+    const ctx = await options.resolveUserContext(user);
+    return ctx ?? {};
+  }
+  return {};
+}
+function formatErrorForLog(error) {
+  if (error instanceof Error) {
+    return error.stack ?? error.message;
+  }
+  return String(error);
+}
+
+export {
+  createSlackSessionMap,
+  createSlackChannelAdapter
+};