@cuylabs/channel-slack 0.9.0 → 0.11.0

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
+};