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

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-IWUYIAY5.js → chunk-QEJ7TAZJ.js}

@@ -1,14 +1,12 @@
 import {
   installSlackAgentAppSurface
-} from "./chunk-M64Z6TYL.js";
+} from "./chunk-P7KK5GQG.js";
 import {
   createSlackAssistantBridge
-} from "./chunk-BFUPAJON.js";
-import {
-  bolt_exports
-} from "./chunk-ANIZ5NT4.js";
+} from "./chunk-ZDVD46RT.js";
 
 // src/socket.ts
+import { createSlackSocketBoltApp } from "@cuylabs/channel-slack/transports/socket";
 async function mountSlackAssistantAgentSocket(options) {
   const {
     appToken: appTokenOption,
@@ -21,7 +19,7 @@ async function mountSlackAssistantAgentSocket(options) {
     start,
     ...bridgeOptions
   } = options;
-  const { boltApp, authMode } = await (0, bolt_exports.createSlackSocketBoltApp)({
+  const { boltApp, authMode } = await createSlackSocketBoltApp({
     appToken: appTokenOption,
     botToken: botTokenOption,
     auth,
@@ -49,7 +47,7 @@ async function mountSlackAgentAppSocket(options) {
     start,
     ...surfaceOptions
   } = options;
-  const { boltApp, authMode } = await (0, bolt_exports.createSlackSocketBoltApp)({
+  const { boltApp, authMode } = await createSlackSocketBoltApp({
     appToken: appTokenOption,
     botToken: botTokenOption,
     auth,

package/dist/{chunk-FDRQOG7Q.js → chunk-TIQGJ52F.js}

@@ -1,22 +1,25 @@
+import {
+  UnsupportedSlackInteractiveRequestError,
+  bridgeAgentEventsToSlack,
+  resolveSlackEventBridgeOptions
+} from "./chunk-NOVWLAVP.js";
+
+// src/adapter/adapter.ts
+import { withinScope } from "@cuylabs/agent-core";
 import {
   extractSlackAuthContext,
   extractSlackUserIdentity,
   isProcessableMessage,
   parseSlackMentionActivity,
   parseSlackMessageActivity,
-  resolveSlackMessageFormatter
-} from "./chunk-GNXWTKQ6.js";
-import {
-  UnsupportedSlackInteractiveRequestError,
-  bridgeAgentEventsToSlack,
-  resolveSlackEventBridgeOptions,
+  resolveSlackMessageFormatter,
   runWithSlackTurnContext
-} from "./chunk-DHPD4XH5.js";
-
-// src/shared/session.ts
-import { resolveThreadAwareSlackSessionId } from "@cuylabs/channel-slack/core";
+} from "@cuylabs/channel-slack/core";
 
 // src/adapter/session-map.ts
+import {
+  resolveThreadAwareSlackSessionId
+} from "@cuylabs/channel-slack/core";
 function createSlackSessionMap(options) {
   const strategy = options.sessionStrategy ?? "thread-aware";
   if (strategy === "custom") {
@@ -61,9 +64,6 @@ function createSlackSessionMap(options) {
   };
 }
 
-// src/adapter/adapter.ts
-import { withinScope } from "@cuylabs/agent-core";
-
 // src/adapter/sink.ts
 function buildThreadPayload(info, respondInThread) {
   if (!respondInThread || info.channelType === "dm") return {};
@@ -465,7 +465,6 @@ function formatErrorForLog(error) {
 }
 
 export {
-  resolveThreadAwareSlackSessionId,
   createSlackSessionMap,
   createSlackChannelAdapter
 };

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

@@ -1,11 +1,11 @@
 import {
   createSlackChannelAdapter
-} from "./chunk-FDRQOG7Q.js";
-import {
-  bolt_exports
-} from "./chunk-ANIZ5NT4.js";
+} from "./chunk-TIQGJ52F.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,

package/dist/{chunk-BFUPAJON.js → chunk-ZDVD46RT.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-NOVWLAVP.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) {
@@ -603,6 +596,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 +610,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 +633,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 +648,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/context-fragments-CQEDcjYR.d.ts

@@ -0,0 +1,30 @@
+import { AgentContextFragmentInput, AgentContextFragmentBuildContext, AgentContextFragmentKind, AgentContextFragmentRole, AgentContextFragmentPlacement, AgentContextFragmentLifetime, AgentContextFragmentBudgetBehavior, AgentMiddleware } from '@cuylabs/agent-core';
+import { SlackAmbientTurnContext } from '@cuylabs/channel-slack/core';
+
+declare const DEFAULT_SLACK_CONTEXT_FRAGMENT_KEY = "slackContextFragment";
+interface SlackContextFragmentPayload extends Partial<Pick<AgentContextFragmentInput, "budgetBehavior" | "dedupeKey" | "kind" | "lifetime" | "maxChars" | "metadata" | "placement" | "role" | "source" | "title">> {
+    content: string;
+}
+interface SlackContextFragmentResolverContext {
+    slack: Readonly<SlackAmbientTurnContext>;
+    step: AgentContextFragmentBuildContext;
+}
+type SlackContextFragmentResolver = (context: SlackContextFragmentResolverContext) => AgentContextFragmentInput | SlackContextFragmentPayload | string | undefined | Promise<AgentContextFragmentInput | SlackContextFragmentPayload | string | undefined>;
+interface SlackContextFragmentMiddlewareOptions {
+    name?: string;
+    contextKey?: string;
+    resolve?: SlackContextFragmentResolver;
+    kind?: AgentContextFragmentKind;
+    role?: AgentContextFragmentRole;
+    placement?: AgentContextFragmentPlacement;
+    lifetime?: AgentContextFragmentLifetime;
+    title?: string;
+    source?: string;
+    budgetBehavior?: AgentContextFragmentBudgetBehavior;
+    maxChars?: number;
+    dedupeKey?: string | ((context: SlackContextFragmentResolverContext) => string | undefined);
+    metadata?: Record<string, unknown> | ((context: SlackContextFragmentResolverContext) => Record<string, unknown> | undefined);
+}
+declare function createSlackContextFragmentMiddleware(options?: SlackContextFragmentMiddlewareOptions): AgentMiddleware;
+
+export { DEFAULT_SLACK_CONTEXT_FRAGMENT_KEY as D, type SlackContextFragmentMiddlewareOptions as S, type SlackContextFragmentPayload as a, type SlackContextFragmentResolver as b, type SlackContextFragmentResolverContext as c, createSlackContextFragmentMiddleware as d };

package/dist/express-assistant.d.ts

@@ -1,7 +1,8 @@
 import { Server } from 'node:http';
 import { Application } from 'express';
 import { App, ExpressReceiver } from '@slack/bolt';
-import { CreateSlackBoltAppOptions, SlackDirectAuthOptions, SlackDirectAuthMode } from '@cuylabs/channel-slack/bolt';
+import { CreateSlackBoltAppOptions } from '@cuylabs/channel-slack/transports/http';
+import { SlackDirectAuthOptions, SlackDirectAuthMode } from '@cuylabs/channel-slack/auth';
 import { C as CreateSlackAssistantBridgeOptions, b as SlackAssistantFeedbackConfig, S as SlackAssistantBridge } from './options-Uf-qmQKN.js';
 import { SlackFeedbackHandler } from '@cuylabs/channel-slack/feedback';
 import '@cuylabs/agent-core';

package/dist/express-assistant.js

@@ -1,12 +1,9 @@
 import {
   mountSlackAssistantAgent
-} from "./chunk-JMLB7A2V.js";
-import "./chunk-BFUPAJON.js";
-import "./chunk-VHGV66M7.js";
-import "./chunk-GNXWTKQ6.js";
-import "./chunk-DHPD4XH5.js";
-import "./chunk-ANIZ5NT4.js";
-import "./chunk-I2KLQ2HA.js";
+} from "./chunk-5NQYLOAW.js";
+import "./chunk-ZDVD46RT.js";
+import "./chunk-ELR6MQD7.js";
+import "./chunk-NOVWLAVP.js";
 export {
   mountSlackAssistantAgent
 };