@cuylabs/channel-slack 0.1.0

package/dist/history.js

@@ -0,0 +1,747 @@
+import {
+  extractSlackMessageText
+} from "./chunk-FPCE5V5Y.js";
+
+// src/history/context/assistant-root.ts
+function normalizeAssistantSurfaceThreadRootMessages(messages, options) {
+  const rootUser = options.assistantSurfaceThreadRootUser;
+  const threadTs = options.activity.threadTs;
+  if (!rootUser?.userId || !threadTs || messages.length === 0) {
+    return [...messages];
+  }
+  const firstMessage = messages[0];
+  if (!firstMessage || firstMessage.role !== "assistant") {
+    return [...messages];
+  }
+  const text = firstMessage.text.trim();
+  if (!text || isLikelyAssistantGreeting(text)) {
+    return [...messages];
+  }
+  const duplicateIndex = messages.findIndex(
+    (message, index) => index > 0 && message.userId === rootUser.userId && normalizeHistoryText(message.text) === normalizeHistoryText(text)
+  );
+  if (duplicateIndex >= 0) {
+    options.onAssistantSurfaceThreadRootNormalized?.({
+      action: "removed-duplicate",
+      channelId: options.activity.channelId,
+      ...options.teamId ?? options.activity.teamId ? { teamId: options.teamId ?? options.activity.teamId } : {},
+      threadTs,
+      userId: rootUser.userId
+    });
+    return messages.slice(1);
+  }
+  options.onAssistantSurfaceThreadRootNormalized?.({
+    action: "corrected-author",
+    channelId: options.activity.channelId,
+    ...options.teamId ?? options.activity.teamId ? { teamId: options.teamId ?? options.activity.teamId } : {},
+    threadTs,
+    userId: rootUser.userId
+  });
+  return [
+    {
+      ...firstMessage,
+      userId: rootUser.userId,
+      botId: void 0,
+      appId: void 0,
+      role: "user",
+      isBot: false
+    },
+    ...messages.slice(1)
+  ];
+}
+function normalizeHistoryText(value) {
+  return value.trim().replace(/\s+/g, " ");
+}
+function isLikelyAssistantGreeting(text) {
+  const normalized = text.trim().toLowerCase();
+  return normalized === "how can i help?" || normalized === "how can i help" || normalized === "hi, how can i help?" || normalized === "hi, how can i help";
+}
+
+// src/history/reader.ts
+var DEFAULT_HISTORY_LIMIT = 15;
+var DEFAULT_HEADER = "Slack conversation history:";
+var DEFAULT_MAX_CHARACTERS = 12e3;
+var DEFAULT_ROLE_LABELS = {
+  assistant: "Assistant",
+  bot: "Bot",
+  system: "System",
+  unknown: "Message",
+  user: "User"
+};
+async function readSlackThreadHistory(options) {
+  const client = resolveConversationsClient(options.client);
+  const response = await client.replies({
+    channel: options.channelId,
+    ts: options.threadTs,
+    limit: options.limit ?? DEFAULT_HISTORY_LIMIT,
+    ...options.cursor ? { cursor: options.cursor } : {},
+    ...options.token ? { token: options.token } : {},
+    ...options.includeAllMetadata !== void 0 ? { include_all_metadata: options.includeAllMetadata } : {},
+    ...options.oldest ? { oldest: options.oldest } : {},
+    ...options.latest ? { latest: options.latest } : {},
+    ...options.inclusive !== void 0 ? { inclusive: options.inclusive } : {}
+  });
+  assertSlackHistoryResponseOk(response, "conversations.replies");
+  return toHistoryPage(response, options.channelId, options.botUserId);
+}
+async function readSlackChannelHistory(options) {
+  const client = resolveConversationsClient(options.client);
+  const response = await client.history({
+    channel: options.channelId,
+    limit: options.limit ?? DEFAULT_HISTORY_LIMIT,
+    ...options.cursor ? { cursor: options.cursor } : {},
+    ...options.token ? { token: options.token } : {},
+    ...options.includeAllMetadata !== void 0 ? { include_all_metadata: options.includeAllMetadata } : {},
+    ...options.oldest ? { oldest: options.oldest } : {},
+    ...options.latest ? { latest: options.latest } : {},
+    ...options.inclusive !== void 0 ? { inclusive: options.inclusive } : {}
+  });
+  assertSlackHistoryResponseOk(response, "conversations.history");
+  const page = toHistoryPage(response, options.channelId, options.botUserId);
+  return options.oldestFirst === false ? page : { ...page, messages: [...page.messages].reverse() };
+}
+function formatSlackHistoryForPrompt(messages, options = {}) {
+  const selected = options.maxMessages && options.maxMessages > 0 ? messages.slice(-options.maxMessages) : messages;
+  const labels = { ...DEFAULT_ROLE_LABELS, ...options.roleLabels ?? {} };
+  const lines = selected.filter((message) => message.text.trim().length > 0).map((message) => {
+    const label = normalizeAuthorLabel(options.formatAuthor?.(message)) ?? labels[message.role];
+    const timestamp = options.includeTimestamps && message.ts ? ` [${message.ts}]` : "";
+    return `${label}${timestamp}: ${message.text.trim()}`;
+  });
+  const header = options.header === false ? void 0 : options.header ?? DEFAULT_HEADER;
+  const text = header ? [header, ...lines].join("\n") : lines.join("\n");
+  const maxCharacters = options.maxCharacters ?? DEFAULT_MAX_CHARACTERS;
+  if (maxCharacters <= 0 || text.length <= maxCharacters) {
+    return text;
+  }
+  return text.slice(0, maxCharacters).trimEnd();
+}
+function toHistoryPage(response, channelId, botUserId) {
+  const messages = (response.messages ?? []).map(
+    (message) => normalizeSlackHistoryMessage(message, channelId, botUserId)
+  ).filter((message) => message !== void 0);
+  const nextCursor = response.response_metadata?.next_cursor;
+  return {
+    messages,
+    ...nextCursor ? { nextCursor } : {},
+    hasMore: response.has_more === true || Boolean(nextCursor)
+  };
+}
+function normalizeSlackHistoryMessage(message, channelId, botUserId) {
+  if (!message.ts) {
+    return void 0;
+  }
+  const userId = readString(message.user);
+  const botId = readString(message.bot_id);
+  const appId = readString(message.app_id);
+  const subtype = readString(readMessageField(message, "subtype"));
+  const text = extractSlackMessageText(message);
+  const isBot = Boolean(botId) || Boolean(message.bot_profile) || Boolean(botUserId) && userId === botUserId;
+  return {
+    channelId,
+    ts: message.ts,
+    ...message.thread_ts ? { threadTs: message.thread_ts } : {},
+    ...userId ? { userId } : {},
+    ...botId ? { botId } : {},
+    ...appId ? { appId } : {},
+    ...subtype ? { subtype } : {},
+    text,
+    role: resolveHistoryRole({ userId, botId, subtype, isBot, botUserId }),
+    isBot,
+    raw: message
+  };
+}
+function resolveHistoryRole(context) {
+  if (context.botUserId && context.userId === context.botUserId) {
+    return "assistant";
+  }
+  if (context.botId || context.isBot) {
+    return "bot";
+  }
+  if (context.userId) {
+    return "user";
+  }
+  if (context.subtype) {
+    return "system";
+  }
+  return "unknown";
+}
+function assertSlackHistoryResponseOk(response, method) {
+  if (response.ok === false) {
+    throw new Error(
+      `${method} failed${response.error ? `: ${response.error}` : ""}`
+    );
+  }
+}
+function readString(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function normalizeAuthorLabel(value) {
+  const trimmed = value?.trim();
+  return trimmed || void 0;
+}
+function resolveConversationsClient(client) {
+  if ("conversations" in client) {
+    return client.conversations;
+  }
+  return client;
+}
+function readMessageField(message, field) {
+  return message[field];
+}
+
+// src/history/context/errors.ts
+var EXPECTED_SLACK_HISTORY_ERRORS = {
+  access_denied: "Slack denied access to the conversation history.",
+  channel_not_found: "The bot could not find this Slack conversation or is not a member.",
+  missing_scope: "The Slack token is missing a history scope for this conversation type.",
+  no_permission: "The bot does not have permission to read this conversation.",
+  not_in_channel: "The bot is not a member of this channel and cannot read its history."
+};
+function toUnavailable(context) {
+  const info = inspectSlackHistoryError(context.error);
+  return {
+    source: context.source,
+    method: context.method,
+    channelId: context.channelId,
+    ...info
+  };
+}
+function inspectSlackHistoryError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  const errorCode = readSlackErrorCode(message);
+  const hint = errorCode ? EXPECTED_SLACK_HISTORY_ERRORS[errorCode] : void 0;
+  return {
+    message,
+    ...errorCode ? { errorCode } : {},
+    expected: Boolean(hint),
+    ...hint ? { hint } : {}
+  };
+}
+function readSlackErrorCode(message) {
+  const normalized = message.trim();
+  const match = /failed:\s*([a-z_]+)/i.exec(normalized);
+  if (match?.[1]) {
+    return match[1];
+  }
+  return EXPECTED_SLACK_HISTORY_ERRORS[normalized] ? normalized : void 0;
+}
+
+// src/history/context/fetch.ts
+function shouldReadTopLevelChannelHistory(options, threadMessages) {
+  if (options.includeTopLevelChannelFallback === false) {
+    return false;
+  }
+  return !options.activity.threadTs || threadMessages.length === 0;
+}
+function shouldReadOriginChannelHistory(options, topLevelChannelMessages) {
+  return Boolean(
+    options.originChannelId && options.originChannelId !== options.activity.channelId && topLevelChannelMessages.length === 0
+  );
+}
+async function readThreadMessages(options, unavailable) {
+  const threadTs = options.activity.threadTs;
+  if (!threadTs) {
+    return [];
+  }
+  try {
+    const page = await readSlackThreadHistory({
+      client: options.client,
+      channelId: options.activity.channelId,
+      threadTs,
+      botUserId: options.botUserId,
+      token: options.token,
+      limit: options.limit
+    });
+    return filterCurrentActivity(page.messages, options.activity);
+  } catch (error) {
+    unavailable.push(
+      toUnavailable({
+        source: "thread",
+        method: "conversations.replies",
+        channelId: options.activity.channelId,
+        error
+      })
+    );
+    return [];
+  }
+}
+async function readTopLevelChannelMessages(options, unavailable) {
+  try {
+    const page = await readSlackChannelHistory({
+      client: options.client,
+      channelId: options.activity.channelId,
+      botUserId: options.botUserId,
+      token: options.token,
+      limit: options.limit,
+      latest: options.activity.messageTs,
+      inclusive: false
+    });
+    return filterCurrentActivity(page.messages, options.activity);
+  } catch (error) {
+    unavailable.push(
+      toUnavailable({
+        source: "channel",
+        method: "conversations.history",
+        channelId: options.activity.channelId,
+        error
+      })
+    );
+    return [];
+  }
+}
+async function readOriginChannelMessages(options, unavailable) {
+  const channelId = options.originChannelId;
+  if (!channelId) {
+    return [];
+  }
+  try {
+    const page = await readSlackChannelHistory({
+      client: options.client,
+      channelId,
+      botUserId: options.botUserId,
+      token: options.token,
+      limit: options.limit,
+      latest: options.activity.messageTs,
+      inclusive: false
+    });
+    return page.messages;
+  } catch (error) {
+    unavailable.push(
+      toUnavailable({
+        source: "origin-channel",
+        method: "conversations.history",
+        channelId,
+        error
+      })
+    );
+    return [];
+  }
+}
+function filterCurrentActivity(messages, activity) {
+  return messages.filter((message) => message.ts !== activity.messageTs);
+}
+
+// src/history/context/format.ts
+async function formatHistorySection(messages, options) {
+  if (messages.length === 0 || !messages.some((message) => message.text.trim().length > 0)) {
+    return void 0;
+  }
+  const authorContext = toAuthorResolverContext(options);
+  const formatAuthor = await createResolvedAuthorFormatter(
+    messages,
+    options.resolveAuthorLabel,
+    authorContext
+  );
+  return formatSlackHistoryForPrompt(messages, {
+    header: options.header,
+    maxCharacters: options.maxCharacters,
+    ...formatAuthor ? { formatAuthor } : {}
+  });
+}
+function boundText(text, maxCharacters) {
+  const trimmed = text.trim();
+  if (!trimmed || maxCharacters === void 0 || maxCharacters <= 0 || trimmed.length <= maxCharacters) {
+    return trimmed;
+  }
+  return trimmed.slice(0, maxCharacters).trimEnd();
+}
+function createCachedAuthorLabelResolver(resolveAuthor, onResolveAuthorError) {
+  if (!resolveAuthor) {
+    return void 0;
+  }
+  const authorByKey = /* @__PURE__ */ new Map();
+  return async (message, context) => {
+    const key = authorCacheKey(message, context);
+    if (!key) {
+      return resolveAuthorSafely(
+        message,
+        context,
+        resolveAuthor,
+        onResolveAuthorError
+      );
+    }
+    let cached = authorByKey.get(key);
+    if (!cached) {
+      cached = resolveAuthorSafely(
+        message,
+        context,
+        resolveAuthor,
+        onResolveAuthorError
+      );
+      authorByKey.set(key, cached);
+    }
+    return cached;
+  };
+}
+function toAuthorResolverContext(context) {
+  return {
+    source: context.source,
+    channelId: context.channelId,
+    ...context.teamId ? { teamId: context.teamId } : {}
+  };
+}
+async function resolveAuthorSafely(message, context, resolveAuthor, onResolveAuthorError) {
+  try {
+    return normalizeAuthorLabel2(await resolveAuthor(message, context));
+  } catch (error) {
+    onResolveAuthorError?.({
+      ...context,
+      ...message.userId ? { userId: message.userId } : {},
+      error
+    });
+    return void 0;
+  }
+}
+async function createResolvedAuthorFormatter(messages, resolveAuthorLabel, context) {
+  if (!resolveAuthorLabel) {
+    return void 0;
+  }
+  const authorByMessage = /* @__PURE__ */ new Map();
+  await Promise.all(
+    messages.map(async (message) => {
+      const author = await resolveAuthorLabel(message, context);
+      if (author) {
+        authorByMessage.set(message, author);
+      }
+    })
+  );
+  if (authorByMessage.size === 0) {
+    return void 0;
+  }
+  return (message) => authorByMessage.get(message);
+}
+function normalizeAuthorLabel2(value) {
+  const trimmed = value?.trim();
+  return trimmed || void 0;
+}
+function authorCacheKey(message, context) {
+  if (message.userId) {
+    return `${context.teamId ?? "unknown-team"}:${message.role}:user:${message.userId}`;
+  }
+  if (message.botId) {
+    return `${context.teamId ?? "unknown-team"}:${message.role}:bot:${message.botId}`;
+  }
+  if (message.appId) {
+    return `${context.teamId ?? "unknown-team"}:${message.role}:app:${message.appId}`;
+  }
+  return void 0;
+}
+
+// src/history/context/visibility.ts
+async function applyHistoryVisibilityPolicy({
+  options,
+  originChannelMessages,
+  threadMessages,
+  topLevelChannelMessages
+}) {
+  const teamId = options.teamId ?? options.activity.teamId;
+  const thread = await applyHistoryVisibilityPolicyForSource({
+    options,
+    messages: threadMessages,
+    source: "thread",
+    channelId: options.activity.channelId,
+    ...teamId ? { teamId } : {}
+  });
+  const topLevelChannel = await applyHistoryVisibilityPolicyForSource({
+    options,
+    messages: topLevelChannelMessages,
+    source: "channel",
+    channelId: options.activity.channelId,
+    ...teamId ? { teamId } : {}
+  });
+  const originChannel = await applyHistoryVisibilityPolicyForSource({
+    options,
+    messages: originChannelMessages,
+    source: "origin-channel",
+    channelId: options.originChannelId ?? options.activity.channelId,
+    ...teamId ? { teamId } : {}
+  });
+  const decisions = [thread, topLevelChannel, originChannel];
+  return {
+    decisions,
+    omittedTotal: decisions.reduce(
+      (total, decision) => total + decision.omittedCount,
+      0
+    ),
+    originChannel,
+    thread,
+    topLevelChannel
+  };
+}
+async function applyHistoryVisibilityPolicyForSource({
+  channelId,
+  messages,
+  options,
+  source,
+  teamId
+}) {
+  const base = {
+    channelId,
+    source,
+    ...teamId ? { teamId } : {}
+  };
+  if (!options.visibilityPolicy) {
+    return {
+      messages: [...messages],
+      mode: "all",
+      omittedCount: 0,
+      source
+    };
+  }
+  try {
+    return await options.visibilityPolicy.filter(messages, {
+      activity: options.activity,
+      botUserId: options.botUserId,
+      ...base
+    });
+  } catch (error) {
+    options.onVisibilityPolicyError?.({
+      ...base,
+      error
+    });
+    return {
+      messages: [],
+      mode: "error",
+      omittedCount: messages.length,
+      source
+    };
+  }
+}
+
+// src/history/context/load.ts
+var DEFAULT_HISTORY_CONTEXT_MAX_CHARACTERS = 12e3;
+async function loadSlackTurnHistoryContext(options) {
+  const maxCharacters = options.maxCharacters ?? DEFAULT_HISTORY_CONTEXT_MAX_CHARACTERS;
+  const unavailable = [];
+  const threadMessages = normalizeAssistantSurfaceThreadRootMessages(
+    await readThreadMessages(options, unavailable),
+    options
+  );
+  const topLevelChannelMessages = shouldReadTopLevelChannelHistory(
+    options,
+    threadMessages
+  ) ? await readTopLevelChannelMessages(options, unavailable) : [];
+  const originChannelMessages = shouldReadOriginChannelHistory(
+    options,
+    topLevelChannelMessages
+  ) ? await readOriginChannelMessages(options, unavailable) : [];
+  const visibility = await applyHistoryVisibilityPolicy({
+    options,
+    threadMessages,
+    topLevelChannelMessages,
+    originChannelMessages
+  });
+  const visibleThreadMessages = visibility.thread.messages;
+  const visibleTopLevelChannelMessages = visibility.topLevelChannel.messages;
+  const visibleOriginChannelMessages = visibility.originChannel.messages;
+  const resolveAuthorLabel = createCachedAuthorLabelResolver(
+    options.resolveAuthor,
+    options.onResolveAuthorError
+  );
+  const teamId = options.teamId ?? options.activity.teamId;
+  const sections = (await Promise.all([
+    formatHistorySection(visibleThreadMessages, {
+      source: "thread",
+      channelId: options.activity.channelId,
+      ...teamId ? { teamId } : {},
+      header: options.headers?.thread ?? "Slack thread history:",
+      maxCharacters,
+      resolveAuthorLabel
+    }),
+    formatHistorySection(visibleTopLevelChannelMessages, {
+      source: "channel",
+      channelId: options.activity.channelId,
+      ...teamId ? { teamId } : {},
+      header: options.headers?.channel ?? "Recent Slack channel history:",
+      maxCharacters,
+      resolveAuthorLabel
+    }),
+    formatHistorySection(visibleOriginChannelMessages, {
+      source: "origin-channel",
+      channelId: options.originChannelId ?? options.activity.channelId,
+      ...teamId ? { teamId } : {},
+      header: options.headers?.originChannel ?? "Recent Slack origin channel history:",
+      maxCharacters,
+      resolveAuthorLabel
+    })
+  ])).filter((section) => Boolean(section));
+  const prompt = boundText(sections.join("\n\n"), maxCharacters);
+  return {
+    ...prompt ? {
+      prompt,
+      fragment: {
+        content: prompt,
+        title: "Slack Conversation History",
+        source: "slack",
+        kind: "slack-context",
+        role: "user",
+        placement: "after-latest-user",
+        lifetime: "turn",
+        budgetBehavior: "droppable",
+        maxChars: maxCharacters,
+        metadata: {
+          threadMessageCount: visibleThreadMessages.length,
+          topLevelChannelMessageCount: visibleTopLevelChannelMessages.length,
+          originChannelMessageCount: visibleOriginChannelMessages.length,
+          visibilityOmittedMessageCount: visibility.omittedTotal,
+          threadVisibilityOmittedMessageCount: visibility.thread.omittedCount,
+          topLevelChannelVisibilityOmittedMessageCount: visibility.topLevelChannel.omittedCount,
+          originChannelVisibilityOmittedMessageCount: visibility.originChannel.omittedCount,
+          unavailableCount: unavailable.length
+        }
+      }
+    } : {},
+    threadMessageCount: visibleThreadMessages.length,
+    topLevelChannelMessageCount: visibleTopLevelChannelMessages.length,
+    originChannelMessageCount: visibleOriginChannelMessages.length,
+    threadVisibilityOmittedMessageCount: visibility.thread.omittedCount,
+    topLevelChannelVisibilityOmittedMessageCount: visibility.topLevelChannel.omittedCount,
+    originChannelVisibilityOmittedMessageCount: visibility.originChannel.omittedCount,
+    visibilityOmittedMessageCount: visibility.omittedTotal,
+    visibility: visibility.decisions,
+    unavailable
+  };
+}
+
+// src/history/inclusion-policy.ts
+function createSlackSupplementalHistoryPolicy({
+  logger,
+  sessionTranscript
+} = {}) {
+  const seenDirectSessionIds = /* @__PURE__ */ new Set();
+  const transcriptCoveredDirectSessionIds = /* @__PURE__ */ new Set();
+  async function hasPersistedConversationMessages(request, sessionId) {
+    if (transcriptCoveredDirectSessionIds.has(sessionId)) {
+      return true;
+    }
+    if (!sessionTranscript) {
+      return void 0;
+    }
+    try {
+      const hasMessages = await sessionTranscript.hasConversationMessages(sessionId);
+      if (hasMessages) {
+        transcriptCoveredDirectSessionIds.add(sessionId);
+      }
+      return hasMessages;
+    } catch (error) {
+      logger?.debug?.("Slack session transcript check failed", {
+        channelId: request.slackActivity.channelId,
+        channelType: request.slackActivity.channelType,
+        error: formatError(error),
+        sessionId,
+        teamId: request.slackActivity.teamId,
+        threadTs: request.slackActivity.threadTs
+      });
+      return void 0;
+    }
+  }
+  return {
+    async decide(request) {
+      if (request.slackActivity.channelType !== "dm") {
+        return {
+          include: true,
+          reason: "shared-slack-surface",
+          source: "shared-surface"
+        };
+      }
+      const sessionId = request.sessionId;
+      if (sessionId) {
+        const transcriptCoversTurn = await hasPersistedConversationMessages(
+          request,
+          sessionId
+        );
+        if (transcriptCoversTurn === true) {
+          return {
+            include: false,
+            reason: "session-transcript-covers-direct-turn",
+            source: "session-transcript"
+          };
+        }
+        if (transcriptCoversTurn === false) {
+          return {
+            include: true,
+            reason: "first-direct-session-turn",
+            source: "session-transcript"
+          };
+        }
+      }
+      if (!sessionId || !seenDirectSessionIds.has(sessionId)) {
+        if (sessionId) {
+          seenDirectSessionIds.add(sessionId);
+        }
+        return {
+          include: true,
+          reason: "first-direct-session-turn",
+          source: "process-memory"
+        };
+      }
+      return {
+        include: false,
+        reason: "session-transcript-covers-direct-turn",
+        source: "process-memory"
+      };
+    }
+  };
+}
+function formatError(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/history/visibility-policy.ts
+function createSlackSupplementalHistoryVisibilityPolicy({
+  allowedUserIds = [],
+  mode = "all"
+} = {}) {
+  const allowedUsers = new Set(
+    Array.from(allowedUserIds, (userId) => userId.trim()).filter(Boolean)
+  );
+  return {
+    async filter(messages, context) {
+      if (mode === "all") {
+        return {
+          messages: [...messages],
+          mode,
+          omittedCount: 0,
+          source: context.source
+        };
+      }
+      const filtered = messages.filter(
+        (message) => isVisibleSlackHistoryMessage(message, context, mode, allowedUsers)
+      );
+      return {
+        messages: filtered,
+        mode,
+        omittedCount: messages.length - filtered.length,
+        source: context.source
+      };
+    }
+  };
+}
+function isVisibleSlackHistoryMessage(message, context, mode, allowedUsers) {
+  if (isAssistantHistoryMessage(message, context.botUserId)) {
+    return true;
+  }
+  if (!message.userId) {
+    return false;
+  }
+  if (mode === "allowed-users-plus-assistant") {
+    return allowedUsers.has(message.userId);
+  }
+  if (mode === "current-user-plus-assistant") {
+    return message.userId === context.activity.userId;
+  }
+  const originalUserId = context.activity.parentUserId ?? context.activity.userId;
+  return message.userId === originalUserId;
+}
+function isAssistantHistoryMessage(message, botUserId) {
+  return message.role === "assistant" || Boolean(botUserId && message.userId === botUserId);
+}
+export {
+  createSlackSupplementalHistoryPolicy,
+  createSlackSupplementalHistoryVisibilityPolicy,
+  formatSlackHistoryForPrompt,
+  loadSlackTurnHistoryContext,
+  readSlackChannelHistory,
+  readSlackThreadHistory
+};