@cuylabs/channel-slack-agent-core 0.1.0

package/dist/chunk-FDRQOG7Q.js

@@ -0,0 +1,471 @@
+import {
+  extractSlackAuthContext,
+  extractSlackUserIdentity,
+  isProcessableMessage,
+  parseSlackMentionActivity,
+  parseSlackMessageActivity,
+  resolveSlackMessageFormatter
+} from "./chunk-GNXWTKQ6.js";
+import {
+  UnsupportedSlackInteractiveRequestError,
+  bridgeAgentEventsToSlack,
+  resolveSlackEventBridgeOptions,
+  runWithSlackTurnContext
+} from "./chunk-DHPD4XH5.js";
+
+// src/shared/session.ts
+import { resolveThreadAwareSlackSessionId } from "@cuylabs/channel-slack/core";
+
+// 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/adapter.ts
+import { withinScope } from "@cuylabs/agent-core";
+
+// 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 {
+    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/scope-attributes.ts
+function buildScopeAttributes(info, user, prep) {
+  return {
+    slackChannelId: info.channelId,
+    slackChannelType: info.channelType,
+    slackUserId: user.userId,
+    slackTeamId: user.teamId,
+    slackThreadTs: info.threadTs,
+    slackIsMention: info.isMention,
+    ...prep.scopeAttributes ?? {}
+  };
+}
+
+// src/adapter/adapter.ts
+var DEFAULT_CLASSIC_INITIAL_STATUS = {
+  status: "Thinking..."
+};
+function createSlackChannelAdapter(options) {
+  const source = resolveTurnSource(options);
+  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,
+      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
+    }
+  );
+  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 {
+      const scopeAttributes = buildScopeAttributes(
+        slackActivity,
+        userIdentity,
+        preparedTurn
+      );
+      await runWithSlackTurnContext(
+        {
+          ...turnRequest,
+          sessionId: finalSessionId,
+          message: finalUserText,
+          ...utilities.setStatus ? { setStatus: utilities.setStatus } : {},
+          ...preparedTurn.context ? { context: preparedTurn.context } : {}
+        },
+        () => withinScope(
+          {
+            kind: "activity",
+            name: preparedTurn.scopeName?.trim() || "slack-activity",
+            sessionId: finalSessionId,
+            attributes: scopeAttributes
+          },
+          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 bridgeAgentEventsToSlack(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));
+    }
+  };
+}
+function resolveTurnSource(options) {
+  const hasAgent = options.agent !== void 0;
+  const hasSource = options.source !== void 0;
+  if (hasAgent === hasSource) {
+    throw new Error(
+      "Provide exactly one of SlackChannelOptions.agent or SlackChannelOptions.source."
+    );
+  }
+  if (options.source) return options.source;
+  if (options.agent) return options.agent;
+  throw new Error(
+    "Provide exactly one of SlackChannelOptions.agent or SlackChannelOptions.source."
+  );
+}
+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 {
+  resolveThreadAwareSlackSessionId,
+  createSlackSessionMap,
+  createSlackChannelAdapter
+};

package/dist/chunk-GNXWTKQ6.js

@@ -0,0 +1,48 @@
+// src/shared/formatting.ts
+import {
+  markdownToSlackMrkdwn,
+  resolveSlackMessageFormatter
+} from "@cuylabs/channel-slack/core";
+
+// src/shared/activity/classify.ts
+import {
+  isProcessableMessage,
+  resolveSlackChannelType,
+  stripLeadingMentions
+} from "@cuylabs/channel-slack/core";
+
+// src/shared/activity/identity.ts
+import {
+  extractSlackAuthContext,
+  extractSlackUserIdentity
+} from "@cuylabs/channel-slack/core";
+
+// src/shared/activity/parse.ts
+import {
+  extractSlackActionToken,
+  parseSlackMentionActivity,
+  parseSlackMessageActivity
+} from "@cuylabs/channel-slack/core";
+
+// src/shared/activity/text.ts
+import {
+  extractSlackAttachmentsText,
+  extractSlackBlocksText,
+  extractSlackMessageText
+} from "@cuylabs/channel-slack/core";
+
+export {
+  markdownToSlackMrkdwn,
+  resolveSlackMessageFormatter,
+  isProcessableMessage,
+  resolveSlackChannelType,
+  stripLeadingMentions,
+  extractSlackAuthContext,
+  extractSlackUserIdentity,
+  extractSlackActionToken,
+  parseSlackMentionActivity,
+  parseSlackMessageActivity,
+  extractSlackAttachmentsText,
+  extractSlackBlocksText,
+  extractSlackMessageText
+};

package/dist/chunk-HFT2FXJP.js

@@ -0,0 +1,12 @@
+import {
+  __reExport
+} from "./chunk-I2KLQ2HA.js";
+
+// src/users/index.ts
+var users_exports = {};
+__reExport(users_exports, users_star);
+import * as users_star from "@cuylabs/channel-slack/users";
+
+export {
+  users_exports
+};

package/dist/chunk-I2KLQ2HA.js

@@ -0,0 +1,22 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+
+export {
+  __export,
+  __reExport
+};

package/dist/chunk-IWUYIAY5.js

@@ -0,0 +1,69 @@
+import {
+  installSlackAgentAppSurface
+} from "./chunk-M64Z6TYL.js";
+import {
+  createSlackAssistantBridge
+} from "./chunk-BFUPAJON.js";
+import {
+  bolt_exports
+} from "./chunk-ANIZ5NT4.js";
+
+// src/socket.ts
+async function mountSlackAssistantAgentSocket(options) {
+  const {
+    appToken: appTokenOption,
+    botToken: botTokenOption,
+    auth,
+    boltAppOptions,
+    socketModeReceiverOptions,
+    feedback: feedbackOption,
+    onFeedback,
+    start,
+    ...bridgeOptions
+  } = options;
+  const { boltApp, authMode } = await (0, bolt_exports.createSlackSocketBoltApp)({
+    appToken: appTokenOption,
+    botToken: botTokenOption,
+    auth,
+    boltAppOptions,
+    socketModeReceiverOptions
+  });
+  const feedback = feedbackOption !== void 0 ? feedbackOption : onFeedback ? { onFeedback } : void 0;
+  const bridge = createSlackAssistantBridge({
+    ...bridgeOptions,
+    ...feedback !== void 0 ? { feedback } : {}
+  });
+  bridge.install(boltApp);
+  if (start !== false) {
+    await boltApp.start();
+  }
+  return { boltApp, bridge, authMode };
+}
+async function mountSlackAgentAppSocket(options) {
+  const {
+    appToken: appTokenOption,
+    botToken: botTokenOption,
+    auth,
+    boltAppOptions,
+    socketModeReceiverOptions,
+    start,
+    ...surfaceOptions
+  } = options;
+  const { boltApp, authMode } = await (0, bolt_exports.createSlackSocketBoltApp)({
+    appToken: appTokenOption,
+    botToken: botTokenOption,
+    auth,
+    boltAppOptions,
+    socketModeReceiverOptions
+  });
+  const { bridge } = installSlackAgentAppSurface(boltApp, surfaceOptions);
+  if (start !== false) {
+    await boltApp.start();
+  }
+  return { boltApp, bridge, authMode };
+}
+
+export {
+  mountSlackAssistantAgentSocket,
+  mountSlackAgentAppSocket
+};