@cuylabs/channel-slack 0.10.0 → 0.11.0

package/dist/assistant/index.js

@@ -1,188 +1,19 @@
 import {
-  extractSlackActionToken
-} from "../chunk-TWJGVDA2.js";
-import {
-  resolveSlackChannelType,
-  stripLeadingMentions
-} from "../chunk-FPCE5V5Y.js";
-
-// src/assistant/thread-context-store.ts
-var ASSISTANT_THREAD_CONTEXT_EVENT_TYPE = "assistant_thread_context";
-function createSlackAssistantThreadContextStore() {
-  const cache = /* @__PURE__ */ new Map();
-  return {
-    async get(args) {
-      args.logger?.debug?.("[channel-slack] thread context store get called");
-      const { channelId, threadTs } = extractThreadInfo(args.payload);
-      const cacheKey = contextCacheKey(channelId, threadTs);
-      const cached = cache.get(cacheKey);
-      if (cached) return cached;
-      const messages = await readThreadMessages(args, channelId, threadTs);
-      const botUserId = args.context?.botUserId;
-      const metadataMessage = findContextMessage(messages, botUserId);
-      const context = toThreadContext(metadataMessage?.metadata?.event_payload);
-      cache.set(cacheKey, context);
-      return context;
-    },
-    async save(args) {
-      args.logger?.debug?.("[channel-slack] thread context store save called");
-      const { channelId, threadTs, context } = extractThreadInfo(args.payload);
-      const cacheKey = contextCacheKey(channelId, threadTs);
-      cache.set(cacheKey, context);
-      const messages = await readThreadMessages(args, channelId, threadTs);
-      const initialMessage = findInitialBotMessage(
-        messages,
-        args.context?.botUserId
-      );
-      if (!initialMessage?.ts) return;
-      await args.client?.chat?.update?.({
-        channel: channelId,
-        ts: initialMessage.ts,
-        text: initialMessage.text ?? "",
-        blocks: Array.isArray(initialMessage.blocks) ? initialMessage.blocks : [],
-        metadata: {
-          event_type: ASSISTANT_THREAD_CONTEXT_EVENT_TYPE,
-          event_payload: context
-        }
-      });
-    }
-  };
-}
-async function readThreadMessages(args, channelId, threadTs) {
-  const replies = args.client?.conversations?.replies;
-  if (typeof replies !== "function") return [];
-  const result = await replies({
-    channel: channelId,
-    ts: threadTs,
-    oldest: threadTs,
-    include_all_metadata: true,
-    limit: 4
-  });
-  return Array.isArray(result.messages) ? result.messages.filter(isSlackMessageWithMetadata) : [];
-}
-function findContextMessage(messages, botUserId) {
-  return messages.find(
-    (message) => isBotAuthoredMessage(message, botUserId) && message.metadata?.event_type === ASSISTANT_THREAD_CONTEXT_EVENT_TYPE
-  ) ?? messages.find(
-    (message) => isBotAuthoredMessage(message, botUserId) && message.metadata?.event_payload
-  );
-}
-function findInitialBotMessage(messages, botUserId) {
-  return messages.find((message) => isBotAuthoredMessage(message, botUserId));
-}
-function isBotAuthoredMessage(message, botUserId) {
-  if (message.subtype) return false;
-  return botUserId ? message.user === botUserId : Boolean(message.user);
-}
-function extractThreadInfo(payload) {
-  const channelId = extractChannelId(payload);
-  const threadTs = extractThreadTs(payload);
-  if (!channelId || !threadTs) {
-    const missing = [];
-    if (!channelId) missing.push("channel_id");
-    if (!threadTs) missing.push("thread_ts");
-    throw new Error(
-      `Assistant payload is missing required properties: ${missing.join(", ")}`
-    );
-  }
-  return {
-    channelId,
-    threadTs,
-    context: extractThreadContext(payload)
-  };
-}
-function extractThreadContext(payload) {
-  if (!isRecord(payload)) return {};
-  const assistantThread = payload.assistant_thread;
-  if (!isRecord(assistantThread) || !isRecord(assistantThread.context)) {
-    return {};
-  }
-  return toThreadContext(assistantThread.context);
-}
-function extractThreadTs(payload) {
-  if (!isRecord(payload)) return void 0;
-  if (isNonEmptyString(payload.thread_ts)) return payload.thread_ts;
-  if (isRecord(payload.assistant_thread) && isNonEmptyString(payload.assistant_thread.thread_ts)) {
-    return payload.assistant_thread.thread_ts;
-  }
-  if (isRecord(payload.message) && isNonEmptyString(payload.message.thread_ts)) {
-    return payload.message.thread_ts;
-  }
-  if (isRecord(payload.previous_message) && isNonEmptyString(payload.previous_message.thread_ts)) {
-    return payload.previous_message.thread_ts;
-  }
-  return void 0;
-}
-function extractChannelId(payload) {
-  if (!isRecord(payload)) return void 0;
-  if (isNonEmptyString(payload.channel)) return payload.channel;
-  if (isRecord(payload.channel) && isNonEmptyString(payload.channel.id)) {
-    return payload.channel.id;
-  }
-  if (isNonEmptyString(payload.channel_id)) return payload.channel_id;
-  if (isRecord(payload.item) && isNonEmptyString(payload.item.channel)) {
-    return payload.item.channel;
-  }
-  if (isRecord(payload.assistant_thread) && isNonEmptyString(payload.assistant_thread.channel_id)) {
-    return payload.assistant_thread.channel_id;
-  }
-  return void 0;
-}
-function toThreadContext(value) {
-  if (!isRecord(value)) return {};
-  return {
-    ...isNonEmptyString(value.channel_id) ? { channel_id: value.channel_id } : {},
-    ...isNonEmptyString(value.team_id) ? { team_id: value.team_id } : {},
-    ..."enterprise_id" in value ? {
-      enterprise_id: typeof value.enterprise_id === "string" ? value.enterprise_id : null
-    } : {}
-  };
-}
-function isSlackMessageWithMetadata(value) {
-  return isRecord(value);
-}
-function contextCacheKey(channelId, threadTs) {
-  return `${channelId}:${threadTs}`;
-}
-function isNonEmptyString(value) {
-  return typeof value === "string" && value.length > 0;
-}
-function isRecord(value) {
-  return typeof value === "object" && value !== null;
-}
-
-// src/assistant/message-parser.ts
-function parseSlackMessageActivityFromMessageEvent(message) {
-  if (!message || typeof message !== "object") return void 0;
-  const m = message;
-  if (m.subtype && m.subtype.length > 0) return void 0;
-  if (typeof m.text !== "string" || m.text.length === 0) return void 0;
-  if (typeof m.thread_ts !== "string" || m.thread_ts.length === 0) {
-    return void 0;
-  }
-  const channel = typeof m.channel === "string" ? m.channel : void 0;
-  if (!channel) return void 0;
-  const threadTs = m.thread_ts;
-  const messageTs = m.ts;
-  const isThread = threadTs !== messageTs;
-  const channelType = resolveSlackChannelType(channel, threadTs, isThread);
-  const rawText = m.text;
-  const text = channelType === "dm" ? rawText.trim() : stripLeadingMentions(rawText);
-  return {
-    channel,
-    threadTs,
-    channelId: channel,
-    channelType,
-    userId: m.user ?? "unknown",
-    teamId: m.team ?? void 0,
-    parentUserId: m.parent_user_id,
-    actionToken: extractSlackActionToken(m),
-    text,
-    isMention: false,
-    ...messageTs ? { messageTs } : {}
-  };
-}
+  createSlackAssistantBridge,
+  createSlackAssistantThreadContextStore,
+  parseSlackMessageActivityFromMessageEvent,
+  resolveAssistantSessionId
+} from "../chunk-Q6YX7HHK.js";
+import "../chunk-RHOIVQLD.js";
+import "../chunk-IRFKUPJN.js";
+import "../chunk-IAQXQESO.js";
+import "../chunk-37RN2YUI.js";
+import "../chunk-3KP3CBCC.js";
+import "../chunk-FPCE5V5Y.js";
+import "../chunk-6WHFQUYQ.js";
 export {
+  createSlackAssistantBridge,
   createSlackAssistantThreadContextStore,
-  parseSlackMessageActivityFromMessageEvent
+  parseSlackMessageActivityFromMessageEvent,
+  resolveAssistantSessionId
 };

package/dist/bolt-app-BM0tiL7c.d.ts

@@ -0,0 +1,49 @@
+import { AppOptions, SocketModeReceiverOptions, App } from '@slack/bolt';
+import { e as SlackDirectAuthOptions, d as SlackDirectAuthMode } from './types-B9NfCVrk.js';
+
+/**
+ * `createSlackSocketBoltApp` — builds a Socket Mode Bolt `App` from the
+ * package's structured auth options. Mirrors `createSlackBoltApp` without
+ * owning any assistant/app surface mounting.
+ */
+
+type ControlledSocketBoltAppOption = "receiver" | "socketMode" | "appToken" | "token" | "authorize" | "botId" | "botUserId" | "clientId" | "clientSecret" | "stateSecret" | "redirectUri" | "installationStore" | "scopes" | "installerOptions";
+type ControlledSocketModeReceiverOption = "appToken" | "clientId" | "clientSecret" | "stateSecret" | "redirectUri" | "installationStore" | "scopes" | "installerOptions" | "logger" | "logLevel";
+interface CreateSlackSocketBoltAppOptions {
+    /**
+     * Slack app-level token (`xapp-...`) with `connections:write` scope.
+     * @default process.env.SLACK_APP_TOKEN
+     */
+    appToken?: string;
+    /**
+     * Convenience override for single-workspace mode.
+     * @default process.env.SLACK_BOT_TOKEN
+     */
+    botToken?: string;
+    /**
+     * Direct-mode auth configuration.
+     *
+     * - omit for single-workspace token mode
+     * - use `{ mode: "oauth", ... }` for Bolt-managed installs
+     * - use `{ mode: "authorize", authorize }` for external token resolution
+     */
+    auth?: SlackDirectAuthOptions;
+    /**
+     * Additional Bolt `App` options passed after this package sets Socket Mode
+     * and auth. Use for logger/clientOptions and non-auth native Bolt config.
+     */
+    boltAppOptions?: Partial<Omit<AppOptions, ControlledSocketBoltAppOption>>;
+    /**
+     * Additional native Socket Mode receiver options. Use this for websocket
+     * health tuning such as ping timeouts, reconnect behavior, and receiver
+     * error handling. Auth/OAuth fields stay controlled by this helper.
+     */
+    socketModeReceiverOptions?: Partial<Omit<SocketModeReceiverOptions, ControlledSocketModeReceiverOption>>;
+}
+interface CreateSlackSocketBoltAppResult {
+    boltApp: App;
+    authMode: SlackDirectAuthMode;
+}
+declare function createSlackSocketBoltApp(options?: CreateSlackSocketBoltAppOptions): Promise<CreateSlackSocketBoltAppResult>;
+
+export { type CreateSlackSocketBoltAppOptions as C, type CreateSlackSocketBoltAppResult as a, createSlackSocketBoltApp as c };

package/dist/{chunk-TWJGVDA2.js → chunk-37RN2YUI.js}

@@ -99,10 +99,97 @@ function extractSlackAuthContext(context, eventUserId) {
   return auth;
 }
 
+// src/shared/turn-context.ts
+import { AsyncLocalStorage } from "async_hooks";
+var store = new AsyncLocalStorage();
+function currentSlackTurnContext() {
+  return store.getStore();
+}
+function runWithSlackTurnContext(value, fn) {
+  return Promise.resolve(store.run({ ...value }, fn));
+}
+
+// src/shared/follow-up.ts
+function formatSlackAttributedFollowUp(message) {
+  const slack = currentSlackTurnContext();
+  if (!slack) {
+    return message;
+  }
+  const sender = formatSlackSender(slack);
+  const conversation = formatSlackConversation(slack);
+  if (!sender && !conversation) {
+    return message;
+  }
+  const lines = ["Additional Slack follow-up for the running request."];
+  if (sender) {
+    lines.push(`Sender: ${sender}`);
+  }
+  if (conversation) {
+    lines.push(`Conversation: ${conversation}`);
+  }
+  lines.push("Message:", message);
+  return lines.join("\n");
+}
+function formatSlackSender(slack) {
+  const userId = slack.slackActivity.userId || slack.user.userId;
+  const displayName = readPreparedSlackDisplayName(slack.context) ?? slack.user.userName;
+  if (displayName && userId) {
+    return `${displayName} (${userId})`;
+  }
+  return displayName ?? userId ?? "unknown Slack user";
+}
+function formatSlackConversation(slack) {
+  const activity = slack.slackActivity;
+  const surface = formatSlackSurface(activity.channelType);
+  const parts = [
+    activity.teamId ? `team ${activity.teamId}` : void 0,
+    activity.channelId ? `channel ${activity.channelId}` : void 0,
+    activity.threadTs ? `thread ${activity.threadTs}` : activity.messageTs ? `message ${activity.messageTs}` : void 0
+  ].filter((part) => Boolean(part));
+  return parts.length > 0 ? `${surface} (${parts.join(", ")})` : surface;
+}
+function formatSlackSurface(channelType) {
+  switch (channelType) {
+    case "dm":
+      return "private Slack DM";
+    case "thread":
+      return "shared Slack thread";
+    case "channel":
+      return "shared Slack channel";
+    case "group":
+      return "shared Slack group conversation";
+    default:
+      return "Slack conversation";
+  }
+}
+function readPreparedSlackDisplayName(context) {
+  const slack = context?.slack;
+  if (!slack || typeof slack !== "object") {
+    return void 0;
+  }
+  const value = slack.userDisplayName;
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+
+// src/shared/session.ts
+function resolveThreadAwareSlackSessionId(info) {
+  if (info.channelType === "dm") {
+    return info.channelId;
+  }
+  if (info.threadTs) {
+    return `${info.channelId}:${info.threadTs}`;
+  }
+  return `${info.channelId}:${info.messageTs ?? info.channelId}`;
+}
+
 export {
   extractSlackActionToken,
   parseSlackMessageActivity,
   parseSlackMentionActivity,
   extractSlackUserIdentity,
-  extractSlackAuthContext
+  extractSlackAuthContext,
+  currentSlackTurnContext,
+  runWithSlackTurnContext,
+  formatSlackAttributedFollowUp,
+  resolveThreadAwareSlackSessionId
 };

package/dist/chunk-LFQCINHI.js

@@ -0,0 +1,187 @@
+import {
+  createSlackAssistantBridge
+} from "./chunk-Q6YX7HHK.js";
+import {
+  createSlackFeedbackBlock
+} from "./chunk-RHOIVQLD.js";
+import {
+  createSlackChannelAdapter
+} from "./chunk-RTDLIYEE.js";
+
+// src/app-surface.ts
+var DEFAULT_TIMEOUT_MS = 12e4;
+var DEFAULT_STREAM_ERROR_MESSAGE = "I ran into an error while preparing this answer. Please try again.";
+function installSlackAppSurface(boltApp, options) {
+  const {
+    respondToMentions,
+    respondToMessages,
+    respondToChannelMessages,
+    resolveMessage,
+    feedback: feedbackOption,
+    onFeedback,
+    timeoutMs,
+    logger,
+    source,
+    prepareTurn,
+    resolveSession,
+    interactive,
+    viewWorkflows,
+    ...assistantBridgeOptions
+  } = options;
+  const feedbackConfig = feedbackOption === false ? void 0 : feedbackOption ?? (onFeedback ? { onFeedback } : {});
+  const assistantFeedback = feedbackOption === false ? false : feedbackConfig;
+  const feedbackBlock = feedbackConfig ? createSlackFeedbackBlock(feedbackConfig) : void 0;
+  const formatStreamError = assistantBridgeOptions.formatStreamError ?? (() => DEFAULT_STREAM_ERROR_MESSAGE);
+  const formatting = assistantBridgeOptions.formatChatMarkdown;
+  const channelSource = createErrorTranslatingSource(source, formatStreamError);
+  const channelFinalArgs = mergeChatStreamFinalArgs(
+    assistantBridgeOptions.chatStreamFinalArgs,
+    feedbackBlock
+  );
+  const bridge = createSlackAssistantBridge({
+    ...assistantBridgeOptions,
+    source,
+    ...assistantFeedback !== void 0 ? { feedback: assistantFeedback } : {},
+    ...timeoutMs !== void 0 ? { timeoutMs } : {},
+    ...logger ? { logger } : {},
+    ...prepareTurn ? { prepareTurn: toAssistantPrepareTurn(prepareTurn) } : {},
+    ...resolveSession ? { resolveSession: toAssistantResolveSession(resolveSession) } : {},
+    ...interactive ? { handleInteractiveRequest: interactive.handleInteractiveRequest } : {}
+  });
+  bridge.install(boltApp);
+  const channelAdapter = createSlackChannelAdapter({
+    source: channelSource,
+    sessionStrategy: assistantBridgeOptions.sessionStrategy,
+    ...resolveSession ? { resolveSession } : {},
+    ...prepareTurn ? { prepareTurn } : {},
+    ...interactive ? { handleInteractiveRequest: interactive.handleInteractiveRequest } : {},
+    streamingMode: "chat-stream",
+    showReasoning: assistantBridgeOptions.showReasoning,
+    showToolUsage: assistantBridgeOptions.showToolUsage,
+    showSubagentToolUsage: assistantBridgeOptions.showSubagentToolUsage,
+    showSubagentResultInTask: assistantBridgeOptions.showSubagentResultInTask,
+    formatToolTitle: assistantBridgeOptions.formatToolTitle,
+    formatToolUpdate: assistantBridgeOptions.formatToolUpdate,
+    formatToolDetails: assistantBridgeOptions.formatToolDetails,
+    formatToolResultOutput: assistantBridgeOptions.formatToolResultOutput,
+    formatToolError: assistantBridgeOptions.formatToolError,
+    formatReasoningUpdate: assistantBridgeOptions.formatReasoningUpdate,
+    chatStreamBufferSize: assistantBridgeOptions.chatStreamBufferSize,
+    chatStreamStartArgs: {
+      ...assistantBridgeOptions.chatStreamStartArgs ?? {},
+      task_display_mode: assistantBridgeOptions.taskDisplayMode ?? "timeline"
+    },
+    publishFinalResponseArtifact: assistantBridgeOptions.publishFinalResponseArtifact,
+    finalResponseArtifactMode: assistantBridgeOptions.finalResponseArtifactMode,
+    finalResponseArtifactStreamThreshold: assistantBridgeOptions.finalResponseArtifactStreamThreshold,
+    formatFinalResponseArtifactContinuationNotice: assistantBridgeOptions.formatFinalResponseArtifactContinuationNotice,
+    formatFinalResponseArtifactMessage: assistantBridgeOptions.formatFinalResponseArtifactMessage,
+    onFinalResponseArtifactError: assistantBridgeOptions.onFinalResponseArtifactError,
+    ...typeof assistantBridgeOptions.initialStatus === "object" && assistantBridgeOptions.initialStatus !== null ? { initialStatus: assistantBridgeOptions.initialStatus } : {},
+    ...formatting?.formatChatMarkdown !== void 0 ? { formatChatMarkdown: formatting.formatChatMarkdown } : {},
+    ...formatting?.formatMessageText ? { formatMessageText: formatting.formatMessageText } : {},
+    timeout: timeoutMs ?? DEFAULT_TIMEOUT_MS,
+    respondToMentions: respondToMentions !== false,
+    respondToMessages: respondToMessages !== false,
+    respondToChannelMessages: respondToChannelMessages === true,
+    ...resolveMessage ? { resolveMessage } : {},
+    chatStreamFinalArgs: channelFinalArgs,
+    ...logger ? { logger } : {},
+    ...logger ? {
+      onError: async (error, info) => {
+        logger.warn?.("slack channel turn failed", {
+          error: formatErrorForLog(error),
+          channelId: info.channelId,
+          userId: info.userId
+        });
+      }
+    } : {}
+  });
+  channelAdapter.mount(boltApp);
+  interactive?.install(boltApp);
+  viewWorkflows?.install(boltApp);
+  return { bridge };
+}
+function mergeChatStreamFinalArgs(base, feedbackBlock) {
+  if (!base && !feedbackBlock) {
+    return void 0;
+  }
+  const configuredBlocks = Array.isArray(base?.blocks) ? base.blocks : [];
+  const blocks = feedbackBlock ? [...configuredBlocks, feedbackBlock] : configuredBlocks;
+  return {
+    ...base ?? {},
+    ...blocks.length > 0 ? { blocks } : {}
+  };
+}
+function toAssistantPrepareTurn(prepareTurn) {
+  return (request) => prepareTurn(toAppTurnRequest(request));
+}
+function toAssistantResolveSession(resolveSession) {
+  return (request) => resolveSession(toAppTurnRequest(request));
+}
+function toAppTurnRequest(request) {
+  const user = {
+    userId: request.message.userId,
+    channelId: request.message.channelId,
+    teamId: request.message.teamId ?? request.auth.teamId,
+    threadTs: request.message.threadTs,
+    messageTs: request.message.messageTs
+  };
+  return {
+    slackActivity: request.message,
+    user,
+    sessionId: request.sessionId,
+    message: request.message.text,
+    auth: request.auth,
+    threadContext: request.threadContext,
+    assistant: request.assistant,
+    client: request.client,
+    rawArgs: request.rawArgs
+  };
+}
+function createErrorTranslatingSource(source, formatStreamError) {
+  return {
+    chat(sessionId, message, options) {
+      const events = source.chat(sessionId, message, options);
+      return translateErrors(events, formatStreamError);
+    }
+  };
+}
+async function* translateErrors(events, formatStreamError) {
+  try {
+    for await (const event of events) {
+      if (event.type === "error") {
+        yield {
+          type: "text-delta",
+          text: `
+
+${formatStreamError(toError(event.error))}`
+        };
+        yield { type: "complete" };
+        return;
+      }
+      yield event;
+    }
+  } catch (error) {
+    yield {
+      type: "text-delta",
+      text: `
+
+${formatStreamError(toError(error))}`
+    };
+    yield { type: "complete" };
+  }
+}
+function toError(value) {
+  return value instanceof Error ? value : new Error(String(value));
+}
+function formatErrorForLog(error) {
+  if (error instanceof Error) {
+    return error.stack ?? error.message;
+  }
+  return String(error);
+}
+
+export {
+  installSlackAppSurface
+};