@cuylabs/channel-slack-agent-core 0.5.1 → 0.7.0

package/dist/{chunk-BFUPAJON.js → chunk-MGBNGG4D.js}

@@ -1,38 +1,13 @@
 import {
-  feedback_exports
-} from "./chunk-VHGV66M7.js";
-import {
-  extractSlackAuthContext,
-  resolveSlackMessageFormatter
-} from "./chunk-GNXWTKQ6.js";
+  SLACK_FEEDBACK_ACTION_ID,
+  createSlackFeedbackBlock,
+  registerSlackFeedbackAction
+} from "./chunk-ELR6MQD7.js";
 import {
   UnsupportedSlackInteractiveRequestError,
   bridgeAgentEventsToSlack,
-  resolveSlackEventBridgeOptions,
-  runWithSlackTurnContext
-} from "./chunk-DHPD4XH5.js";
-
-// src/assistant/message-parser.ts
-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/thread-context-store.ts
-import {
-  createSlackAssistantThreadContextStore
-} from "@cuylabs/channel-slack/assistant";
+  resolveSlackEventBridgeOptions
+} from "./chunk-TMADMHBN.js";
 
 // src/assistant/bridge.ts
 import { Assistant } from "@slack/bolt";
@@ -190,6 +165,24 @@ function createThreadContextChangedHandler() {
 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) {
@@ -246,6 +239,11 @@ function createAssistantSink(params) {
     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."
@@ -434,6 +432,7 @@ function createUserMessageHandler(deps) {
         ...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 } : {},
@@ -441,6 +440,22 @@ function createUserMessageHandler(deps) {
         ...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(
@@ -603,6 +618,7 @@ ${formatStreamError(translatedError)}`
 }
 
 // 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(
@@ -616,8 +632,8 @@ function createSlackAssistantBridge(options) {
   }
   const sessionStrategy = options.sessionStrategy ?? "thread-aware";
   const feedbackConfig = options.feedback === false ? void 0 : options.feedback ?? {};
-  const feedbackBlock = feedbackConfig ? (0, feedback_exports.createSlackFeedbackBlock)(feedbackConfig) : void 0;
-  const feedbackActionId = feedbackConfig?.actionId ?? feedback_exports.SLACK_FEEDBACK_ACTION_ID;
+  const feedbackBlock = feedbackConfig ? createSlackFeedbackBlock(feedbackConfig) : void 0;
+  const feedbackActionId = feedbackConfig?.actionId ?? SLACK_FEEDBACK_ACTION_ID;
   const threadStarted = createThreadStartedHandler(options);
   const threadContextChanged = createThreadContextChangedHandler();
   const threadContextStore = options.threadContextStore ?? createSlackAssistantThreadContextStore();
@@ -639,7 +655,7 @@ function createSlackAssistantBridge(options) {
   function install(app) {
     app.assistant(assistant);
     if (feedbackConfig) {
-      (0, feedback_exports.registerSlackFeedbackAction)(app, {
+      registerSlackFeedbackAction(app, {
         ...feedbackConfig,
         resolveSessionId: (context) => resolveFeedbackSessionId(context, sessionStrategy),
         onFeedback: feedbackConfig.onFeedback ?? (async (_ctx) => {
@@ -654,9 +670,15 @@ function createSlackAssistantBridge(options) {
   };
 }
 
+// src/assistant/index.ts
+import {
+  createSlackAssistantThreadContextStore as createSlackAssistantThreadContextStore2,
+  parseSlackMessageActivityFromMessageEvent as parseSlackMessageActivityFromMessageEvent2
+} from "@cuylabs/channel-slack/assistant";
+
 export {
-  parseSlackMessageActivityFromMessageEvent,
   resolveAssistantSessionId,
-  createSlackAssistantThreadContextStore,
-  createSlackAssistantBridge
+  createSlackAssistantBridge,
+  createSlackAssistantThreadContextStore2 as createSlackAssistantThreadContextStore,
+  parseSlackMessageActivityFromMessageEvent2 as parseSlackMessageActivityFromMessageEvent
 };

package/dist/chunk-NNCVHQC4.js

@@ -0,0 +1,94 @@
+// src/artifacts/final-response.ts
+import {
+  publishSlackCanvasArtifact,
+  publishSlackTextArtifact
+} from "@cuylabs/channel-slack/artifacts";
+var DEFAULT_MIN_CHARACTERS = 4e3;
+var DEFAULT_TITLE = "Agent response";
+function createSlackFinalResponseArtifactPublisher({
+  minCharacters = DEFAULT_MIN_CHARACTERS,
+  title = DEFAULT_TITLE,
+  summary,
+  channelCanvas = true,
+  fallback = "file",
+  onPublished,
+  onError
+} = {}) {
+  const configuredThreshold = Math.floor(minCharacters);
+  const threshold = Number.isFinite(configuredThreshold) && configuredThreshold > 0 ? configuredThreshold : DEFAULT_MIN_CHARACTERS;
+  return async (context) => {
+    const text = context.text.trim();
+    if (text.length < threshold) {
+      return void 0;
+    }
+    const resolvedTitle = normalizeText(await resolveValue(title, context)) ?? DEFAULT_TITLE;
+    const resolvedSummary = normalizeText(await resolveValue(summary, context));
+    let lastError;
+    try {
+      const publication = await publishSlackCanvasArtifact({
+        client: context.client,
+        channelId: context.channelId,
+        ...context.threadTs ? { threadTs: context.threadTs } : {},
+        artifact: {
+          kind: "canvas",
+          title: resolvedTitle,
+          markdown: text,
+          channelCanvas,
+          ...resolvedSummary ? { summary: resolvedSummary } : {},
+          metadata: {
+            source: "slack-final-response",
+            characterCount: text.length
+          }
+        }
+      });
+      const result = { publication };
+      await onPublished?.(result, context);
+      return result;
+    } catch (error) {
+      lastError = error;
+    }
+    if (fallback === "file") {
+      try {
+        const publication = await publishSlackTextArtifact({
+          client: context.client,
+          channelId: context.channelId,
+          ...context.threadTs ? { threadTs: context.threadTs } : {},
+          artifact: {
+            kind: "text",
+            title: resolvedTitle,
+            text,
+            filename: filenameFromTitle(resolvedTitle),
+            ...resolvedSummary ? { summary: resolvedSummary } : {},
+            metadata: {
+              source: "slack-final-response",
+              characterCount: text.length,
+              canvasFallback: true
+            }
+          }
+        });
+        const result = { publication };
+        await onPublished?.(result, context);
+        return result;
+      } catch (error) {
+        lastError = error;
+      }
+    }
+    await onError?.(lastError, context);
+    return void 0;
+  };
+}
+async function resolveValue(value, context) {
+  return typeof value === "function" ? await value(context) : value;
+}
+function normalizeText(value) {
+  const trimmed = value?.trim();
+  return trimmed ? trimmed : void 0;
+}
+function filenameFromTitle(title) {
+  const slug = title.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  return `${slug || "agent-response"}.txt`;
+}
+
+export {
+  createSlackFinalResponseArtifactPublisher
+};

package/dist/chunk-P7PFQ3SQ.js

@@ -0,0 +1,396 @@
+// src/history/turn-context.ts
+import {
+  createSlackSupplementalHistoryVisibilityPolicy,
+  loadSlackTurnHistoryContext
+} from "@cuylabs/channel-slack/history";
+import { enrichSlackUserMentions } from "@cuylabs/channel-slack/users";
+import { WebClient } from "@slack/web-api";
+async function loadSlackAgentTurnHistoryContext({
+  history,
+  logger,
+  originChannelId: providedOriginChannelId,
+  profileResolver,
+  request
+}) {
+  const originChannelId = providedOriginChannelId ?? resolveOriginChannelId(request);
+  const client = resolveSlackHistoryClient(request);
+  if (!history.enabled) {
+    logger?.debug?.("Slack context history disabled", {
+      channelId: request.slackActivity.channelId,
+      threadTs: request.slackActivity.threadTs
+    });
+    return emptySlackAgentTurnHistoryContextResult();
+  }
+  if (!client) {
+    logger?.warn?.("Slack context history enabled without a Slack WebClient", {
+      channelId: request.slackActivity.channelId,
+      threadTs: request.slackActivity.threadTs
+    });
+    return emptySlackAgentTurnHistoryContextResult();
+  }
+  const teamId = request.slackActivity.teamId ?? request.user.teamId ?? request.auth?.teamId;
+  const threadTs = request.slackActivity.threadTs ?? request.slackActivity.messageTs;
+  const resolveAuthor = profileResolver ? createSlackAgentHistoryAuthorResolver({
+    botToken: request.auth?.botToken,
+    logger,
+    profileResolver,
+    teamId
+  }) : void 0;
+  const loaded = await loadSlackTurnHistoryContext({
+    activity: request.slackActivity,
+    botUserId: request.auth?.botUserId,
+    client,
+    includeTopLevelChannelFallback: request.slackActivity.channelType !== "dm",
+    limit: history.limit,
+    maxCharacters: history.maxCharacters,
+    token: request.auth?.botToken,
+    ...teamId ? { teamId } : {},
+    ...originChannelId ? { originChannelId } : {},
+    visibilityPolicy: createSlackSupplementalHistoryVisibilityPolicy({
+      allowedUserIds: history.visibilityAllowedUserIds ?? [],
+      mode: history.visibilityMode ?? "all"
+    }),
+    onVisibilityPolicyError: ({ channelId, error, source, teamId: teamId2 }) => {
+      logger?.warn?.("Slack supplemental history visibility policy failed", {
+        channelId,
+        source,
+        ...teamId2 ? { teamId: teamId2 } : {},
+        error: formatHistoryError(error)
+      });
+    },
+    ...request.assistant ? {
+      assistantSurfaceThreadRootUser: {
+        userId: request.slackActivity.userId
+      },
+      onAssistantSurfaceThreadRootNormalized: ({
+        action,
+        channelId,
+        teamId: normalizedTeamId,
+        threadTs: threadTs2,
+        userId
+      }) => {
+        logger?.debug?.(
+          action === "removed-duplicate" ? "Slack assistant surface duplicate thread root removed" : "Slack assistant surface thread root author corrected",
+          {
+            channelId,
+            ...normalizedTeamId ? { teamId: normalizedTeamId } : {},
+            threadTs: threadTs2,
+            userId
+          }
+        );
+      }
+    } : {},
+    headers: {
+      channel: "Recent Slack channel history before the current message:",
+      ...originChannelId ? {
+        originChannel: `Recent Slack channel context from ${originChannelId}:`
+      } : {},
+      thread: "Recent Slack thread history before the current message:"
+    },
+    ...resolveAuthor ? { resolveAuthor } : {},
+    ...resolveAuthor ? {
+      onResolveAuthorError: ({
+        channelId,
+        error,
+        source,
+        teamId: errorTeamId,
+        userId
+      }) => {
+        logger?.debug?.("Slack history author attribution failed", {
+          channelId,
+          source,
+          ...errorTeamId ? { teamId: errorTeamId } : {},
+          ...userId ? { userId } : {},
+          error: formatHistoryError(error)
+        });
+      }
+    } : {}
+  });
+  const unavailableReasons = summarizeUnavailable(loaded.unavailable);
+  for (const issue of loaded.unavailable) {
+    logSlackAgentHistoryUnavailable(logger, issue);
+  }
+  const loadedPrompt = await enrichSlackAgentHistoryMentions({
+    botToken: request.auth?.botToken,
+    logger,
+    profileResolver,
+    prompt: loaded.prompt,
+    teamId
+  });
+  const prompt = truncateHistoryPrompt(
+    [
+      loadedPrompt,
+      ...loaded.unavailable.map(
+        (issue) => (history.unavailableNoteFormatter ?? formatSlackAgentHistoryUnavailableNote)(issue)
+      )
+    ].filter(Boolean).join("\n\n"),
+    history
+  );
+  const fragment = prompt ? createSlackAgentHistoryFragment({
+    history,
+    loadedFragment: loaded.fragment,
+    prompt,
+    unavailableReasons
+  }) : void 0;
+  logger?.debug?.("Slack context history loaded", {
+    channelId: request.slackActivity.channelId,
+    included: Boolean(prompt),
+    maxCharacters: history.maxCharacters,
+    maxMessages: history.limit,
+    originChannelId,
+    originChannelMessageCount: loaded.originChannelMessageCount,
+    originChannelUnavailableReason: unavailableReasons.originChannelUnavailableReason,
+    promptChars: prompt?.length ?? 0,
+    threadMessageCount: loaded.threadMessageCount,
+    threadTs,
+    threadUnavailableReason: unavailableReasons.threadUnavailableReason,
+    topLevelChannelMessageCount: loaded.topLevelChannelMessageCount,
+    topLevelChannelUnavailableReason: unavailableReasons.topLevelChannelUnavailableReason
+  });
+  return {
+    ...fragment ? { fragment } : {},
+    ...prompt ? { prompt } : {},
+    originChannelMessageCount: loaded.originChannelMessageCount,
+    originChannelVisibilityOmittedMessageCount: loaded.originChannelVisibilityOmittedMessageCount,
+    threadMessageCount: loaded.threadMessageCount,
+    threadVisibilityOmittedMessageCount: loaded.threadVisibilityOmittedMessageCount,
+    topLevelChannelMessageCount: loaded.topLevelChannelMessageCount,
+    topLevelChannelVisibilityOmittedMessageCount: loaded.topLevelChannelVisibilityOmittedMessageCount,
+    visibilityOmittedMessageCount: loaded.visibilityOmittedMessageCount,
+    ...unavailableReasons.originChannelUnavailableReason ? {
+      originChannelUnavailableReason: unavailableReasons.originChannelUnavailableReason
+    } : {},
+    ...unavailableReasons.threadUnavailableReason ? { threadUnavailableReason: unavailableReasons.threadUnavailableReason } : {},
+    ...unavailableReasons.topLevelChannelUnavailableReason ? {
+      topLevelChannelUnavailableReason: unavailableReasons.topLevelChannelUnavailableReason
+    } : {}
+  };
+}
+function emptySlackAgentTurnHistoryContextResult() {
+  return {
+    originChannelMessageCount: 0,
+    originChannelVisibilityOmittedMessageCount: 0,
+    threadMessageCount: 0,
+    threadVisibilityOmittedMessageCount: 0,
+    topLevelChannelMessageCount: 0,
+    topLevelChannelVisibilityOmittedMessageCount: 0,
+    visibilityOmittedMessageCount: 0
+  };
+}
+async function enrichSlackAgentHistoryMentions({
+  botToken,
+  logger,
+  profileResolver,
+  prompt,
+  teamId
+}) {
+  if (!prompt || !profileResolver) {
+    return prompt;
+  }
+  const result = await enrichSlackUserMentions(
+    {
+      text: prompt,
+      ...botToken ? { botToken } : {},
+      ...teamId ? { teamId } : {}
+    },
+    {
+      concurrency: 4,
+      formatLabel: ({ mention, profile }) => profile.displayName ? `${mention} (${profile.displayName})` : void 0,
+      maxLookups: 20,
+      onResolveError: ({ error, teamId: errorTeamId, userId }) => {
+        logger?.debug?.("Slack history mention enrichment failed", {
+          ...errorTeamId ? { teamId: errorTeamId } : {},
+          error: formatHistoryError(error),
+          userId
+        });
+      },
+      profileResolver: {
+        resolve: async (input) => ({
+          userId: input.userId,
+          ...await profileResolver.resolve({
+            botToken: input.botToken,
+            teamId: input.teamId,
+            userId: input.userId
+          })
+        })
+      }
+    }
+  );
+  return result.text;
+}
+function createSlackAgentHistoryAuthorResolver({
+  botToken,
+  logger,
+  profileResolver,
+  teamId
+}) {
+  return async (message, context) => {
+    if (message.role === "assistant") {
+      return "Assistant";
+    }
+    if (message.role === "bot") {
+      return "Bot";
+    }
+    if (!message.userId) {
+      return void 0;
+    }
+    try {
+      const profile = await profileResolver.resolve({
+        botToken,
+        teamId: context.teamId ?? teamId,
+        userId: message.userId
+      });
+      return formatSlackHistoryUserAuthor(message.userId, profile.displayName);
+    } catch (error) {
+      logger?.debug?.("Slack history profile lookup failed", {
+        channelId: context.channelId,
+        error: formatHistoryError(error),
+        source: context.source,
+        teamId: context.teamId ?? teamId,
+        userId: message.userId
+      });
+      return formatSlackHistoryUserAuthor(message.userId);
+    }
+  };
+}
+function formatSlackHistoryUserAuthor(userId, displayName) {
+  return displayName ? `${displayName} (${userId})` : `Slack user ${userId}`;
+}
+function createSlackAgentHistoryFragment({
+  history,
+  loadedFragment,
+  prompt,
+  unavailableReasons
+}) {
+  return {
+    ...loadedFragment,
+    budgetBehavior: loadedFragment?.budgetBehavior ?? "droppable",
+    content: prompt,
+    kind: loadedFragment?.kind ?? "slack-context",
+    lifetime: loadedFragment?.lifetime ?? "turn",
+    maxChars: loadedFragment?.maxChars ?? history.maxCharacters,
+    metadata: {
+      ...loadedFragment?.metadata,
+      ...unavailableReasons.originChannelUnavailableReason ? {
+        originChannelUnavailableReason: unavailableReasons.originChannelUnavailableReason
+      } : {},
+      ...unavailableReasons.threadUnavailableReason ? {
+        threadUnavailableReason: unavailableReasons.threadUnavailableReason
+      } : {},
+      ...unavailableReasons.topLevelChannelUnavailableReason ? {
+        topLevelChannelUnavailableReason: unavailableReasons.topLevelChannelUnavailableReason
+      } : {}
+    },
+    placement: loadedFragment?.placement ?? "after-latest-user",
+    role: loadedFragment?.role ?? "user",
+    source: loadedFragment?.source ?? "slack",
+    title: loadedFragment?.title ?? "Slack Conversation History"
+  };
+}
+function logSlackAgentHistoryUnavailable(logger, issue) {
+  const fields = {
+    channelId: issue.channelId,
+    error: issue.message,
+    expected: issue.expected,
+    ...normalizedHistoryHint(issue) ? { hint: normalizedHistoryHint(issue) } : {},
+    method: issue.method,
+    slackError: normalizedHistoryErrorCode(issue) ?? "unknown",
+    source: issue.source
+  };
+  if (issue.expected) {
+    logger?.info?.("Slack context history unavailable", fields);
+  } else {
+    logger?.warn?.("Slack context history unavailable", fields);
+  }
+}
+function formatSlackAgentHistoryUnavailableNote(issue) {
+  const reason = normalizedHistoryErrorCode(issue) ?? "unknown_error";
+  const hint = normalizedHistoryHint(issue);
+  return [
+    `${historyScopeLabel(issue)} context is unavailable to the app for this turn (${reason}).`,
+    `If the user asks about that Slack context, say that you cannot read it yet and explain the needed access.${hint ? ` ${normalizeHistoryHint(hint)}` : ""}`
+  ].join(" ");
+}
+function historyScopeLabel(issue) {
+  switch (issue.source) {
+    case "thread":
+      return "current assistant thread";
+    case "channel":
+      return `current Slack channel ${issue.channelId}`;
+    case "origin-channel":
+      return `origin Slack channel ${issue.channelId}`;
+  }
+}
+function normalizeHistoryHint(hint) {
+  return hint.endsWith(".") ? hint : `${hint}.`;
+}
+function summarizeUnavailable(unavailable) {
+  return {
+    originChannelUnavailableReason: unavailableReason(
+      unavailable,
+      "origin-channel"
+    ),
+    threadUnavailableReason: unavailableReason(unavailable, "thread"),
+    topLevelChannelUnavailableReason: unavailableReason(unavailable, "channel")
+  };
+}
+function unavailableReason(unavailable, source) {
+  const issue = unavailable.find((entry) => entry.source === source);
+  return issue ? normalizedHistoryErrorCode(issue) ?? issue.message : void 0;
+}
+function normalizedHistoryErrorCode(issue) {
+  if (issue.errorCode) {
+    return issue.errorCode;
+  }
+  const failedMatch = issue.message.match(/failed:\s*([a-z_]+)/i);
+  if (failedMatch?.[1]) {
+    return failedMatch[1];
+  }
+  const apiMatch = issue.message.match(/API error occurred:\s*([a-z_]+)/i);
+  return apiMatch?.[1];
+}
+function normalizedHistoryHint(issue) {
+  if (issue.hint) {
+    return issue.hint;
+  }
+  switch (normalizedHistoryErrorCode(issue)) {
+    case "not_in_channel":
+      return "Invite the app to the channel, then retry.";
+    case "channel_not_found":
+      return "Slack did not expose a readable channel for this bot token.";
+    case "no_permission":
+    case "access_denied":
+      return "The bot token cannot read this conversation.";
+    case "missing_scope":
+      return "Add the matching Slack history scope and reinstall the app.";
+    default:
+      return void 0;
+  }
+}
+function resolveSlackHistoryClient(request) {
+  if (request.client) {
+    return request.client;
+  }
+  return request.auth?.botToken ? new WebClient(request.auth.botToken) : void 0;
+}
+function resolveOriginChannelId(request) {
+  return request.threadContext?.channel_id && request.threadContext.channel_id !== request.slackActivity.channelId ? request.threadContext.channel_id : void 0;
+}
+function truncateHistoryPrompt(value, history) {
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return void 0;
+  }
+  if (trimmed.length <= history.maxCharacters) {
+    return trimmed;
+  }
+  return trimmed.slice(0, history.maxCharacters).trimEnd();
+}
+function formatHistoryError(error) {
+  return error instanceof Error ? error.stack ?? error.message : String(error);
+}
+
+export {
+  loadSlackAgentTurnHistoryContext,
+  emptySlackAgentTurnHistoryContextResult
+};

package/dist/{chunk-WO4BJMF3.js → chunk-TCNJY7QA.js}

@@ -1,11 +1,11 @@
 import {
   createSlackChannelAdapter
-} from "./chunk-FDRQOG7Q.js";
-import {
-  bolt_exports
-} from "./chunk-ANIZ5NT4.js";
+} from "./chunk-FQWFB54C.js";
 
 // src/express.ts
+import {
+  createSlackBoltApp
+} from "@cuylabs/channel-slack/transports/http";
 async function mountSlackAgent(source, options = {}) {
   const {
     botToken: providedToken,
@@ -27,7 +27,7 @@ async function mountSlackAgent(source, options = {}) {
     app: expressApp,
     authMode,
     routePath
-  } = await (0, bolt_exports.createSlackBoltApp)({
+  } = await createSlackBoltApp({
     signingSecret,
     path,
     botToken: providedToken,