@cuylabs/channel-slack-agent-core 0.1.0

package/dist/chunk-BFUPAJON.js

@@ -0,0 +1,662 @@
+import {
+  feedback_exports
+} from "./chunk-VHGV66M7.js";
+import {
+  extractSlackAuthContext,
+  resolveSlackMessageFormatter
+} from "./chunk-GNXWTKQ6.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";
+
+// src/assistant/bridge.ts
+import { Assistant } from "@slack/bolt";
+
+// src/assistant/options.ts
+var DEFAULT_INITIAL_REPLY = "Hi, how can I help?";
+var DEFAULT_INITIAL_STATUS = {
+  status: "Thinking..."
+};
+var DEFAULT_STREAM_ERROR_MESSAGE = "I ran into an error while preparing this answer. Please try again.";
+
+// src/assistant/helpers.ts
+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);
+}
+async function safeGetThreadContext(getThreadContext, logger) {
+  try {
+    const value = await getThreadContext();
+    if (value && typeof value === "object") {
+      return value;
+    }
+  } catch (error) {
+    logger.warn?.("getThreadContext failed", {
+      error: formatErrorForLog(error)
+    });
+  }
+  return {};
+}
+async function resolveInitialReply(resolver, context) {
+  if (resolver === void 0) {
+    return DEFAULT_INITIAL_REPLY;
+  }
+  const value = await resolver(context);
+  if (value === false) {
+    return void 0;
+  }
+  return value ?? void 0;
+}
+async function resolveInitialStatus(resolver, request) {
+  if (resolver === void 0) {
+    return DEFAULT_INITIAL_STATUS;
+  }
+  if (typeof resolver === "function") {
+    return await resolver(request) ?? void 0;
+  }
+  return resolver;
+}
+async function resolveStatusUpdate(resolver, label, event, rawArgs) {
+  if (!resolver) {
+    return label ? { status: label } : { status: "" };
+  }
+  if (!event) {
+    return void 0;
+  }
+  return await resolver({ event, rawArgs }) ?? void 0;
+}
+function resolveFeedbackSessionId(context, strategy) {
+  const threadTs = context.threadTs ?? context.messageTs;
+  switch (strategy) {
+    case "channel-id":
+      return context.channelId;
+    case "user-per-thread":
+      return `${context.channelId}:${threadTs}:${context.userId}`;
+    default:
+      return `${context.channelId}:${threadTs}`;
+  }
+}
+
+// src/assistant/lifecycle/thread-started.ts
+function createThreadStartedHandler(options) {
+  return async (args) => {
+    const {
+      event,
+      context,
+      client,
+      logger,
+      say,
+      setSuggestedPrompts,
+      saveThreadContext
+    } = args;
+    const threadCtx = {
+      event,
+      context,
+      client,
+      logger
+    };
+    let savedThreadContext = false;
+    const saveContext = async () => {
+      if (savedThreadContext) return;
+      try {
+        await saveThreadContext();
+        savedThreadContext = true;
+      } catch (error) {
+        logger.error(
+          `[channel-slack-agent-core] saveThreadContext failed: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    };
+    try {
+      const initialReply = await resolveInitialReply(
+        options.getInitialReply,
+        threadCtx
+      );
+      if (initialReply) {
+        await say(initialReply);
+      }
+    } catch (error) {
+      logger.error(
+        `[channel-slack-agent-core] initial assistant reply failed: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+    await saveContext();
+    try {
+      const prompts = await options.getSuggestedPrompts?.(threadCtx);
+      if (prompts && prompts.prompts.length > 0) {
+        await setSuggestedPrompts({
+          ...prompts.title ? { title: prompts.title } : {},
+          prompts: prompts.prompts
+        });
+      }
+    } catch (error) {
+      logger.error(
+        `[channel-slack-agent-core] setSuggestedPrompts failed: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  };
+}
+
+// src/assistant/lifecycle/thread-context-changed.ts
+function createThreadContextChangedHandler() {
+  return async ({ event, saveThreadContext, logger }) => {
+    try {
+      await saveThreadContext();
+      logger.info("[channel-slack-agent-core] thread context changed saved", {
+        channelId: event.assistant_thread.channel_id,
+        threadTs: event.assistant_thread.thread_ts,
+        originChannelId: event.assistant_thread.context.channel_id,
+        teamId: event.assistant_thread.context.team_id
+      });
+    } catch (error) {
+      logger.error(
+        `[channel-slack-agent-core] threadContextChanged failed: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  };
+}
+
+// src/assistant/lifecycle/user-message.ts
+import {
+  withinScope
+} from "@cuylabs/agent-core";
+
+// src/assistant/scope-attributes.ts
+function buildAssistantScopeAttributes(message, auth, threadContext, prep) {
+  return {
+    slackChannelId: message.channelId,
+    slackChannelType: message.channelType,
+    slackUserId: message.userId,
+    slackTeamId: message.teamId ?? auth.teamId,
+    slackEnterpriseId: auth.enterpriseId,
+    slackThreadTs: message.threadTs,
+    slackMessageTs: message.messageTs,
+    slackAssistantOriginChannelId: threadContext.channel_id,
+    ...prep.scopeAttributes ?? {}
+  };
+}
+
+// src/assistant/sink.ts
+function createAssistantSink(params) {
+  let stream;
+  let stopped = false;
+  function ensureStream(bufferSize) {
+    if (stream) return stream;
+    const streamArgs = {
+      ...params.chatStreamStartArgs ?? {},
+      task_display_mode: params.taskDisplayMode,
+      buffer_size: bufferSize
+    };
+    let created;
+    if (typeof params.sayStream === "function") {
+      created = params.sayStream(streamArgs);
+    } else {
+      const clientWithStream = params.client;
+      if (typeof clientWithStream.chatStream !== "function") {
+        throw new Error(
+          "Slack client does not expose chatStream; ensure @slack/web-api >=7.16.0 is installed."
+        );
+      }
+      created = clientWithStream.chatStream({
+        channel: params.channel,
+        thread_ts: params.threadTs,
+        ...params.teamId ? { recipient_team_id: params.teamId } : {},
+        ...params.userId ? { recipient_user_id: params.userId } : {},
+        ...streamArgs
+      });
+    }
+    stream = {
+      append: (args) => created.append(args),
+      stop: async (args) => {
+        if (stopped) return void 0;
+        stopped = true;
+        return created.stop(args);
+      }
+    };
+    return stream;
+  }
+  return {
+    async postMessage() {
+      throw new Error(
+        "Assistant bridge uses chat-stream mode and does not support postMessage."
+      );
+    },
+    async updateMessage() {
+    },
+    createChatStream: ({ bufferSize }) => ensureStream(bufferSize),
+    async appendError(text) {
+      if (stopped) return;
+      const target = ensureStream(256);
+      await target.append({ markdown_text: `
+
+${text}` });
+    },
+    async finalize() {
+      if (stopped || !stream) return;
+      await stream.stop();
+    }
+  };
+}
+function createAssistantInteractiveResponder(params) {
+  return {
+    async postMessage(message) {
+      const result = await params.client.chat.postMessage({
+        channel: params.channel,
+        thread_ts: params.threadTs,
+        text: message.text,
+        ...message.blocks ? { blocks: message.blocks } : {}
+      });
+      if (!result.channel || !result.ts) {
+        throw new Error(
+          "Slack chat.postMessage response did not include channel and ts."
+        );
+      }
+      return { channel: result.channel, ts: result.ts };
+    },
+    async updateMessage(ref, message) {
+      await params.client.chat.update({
+        channel: ref.channel,
+        ts: ref.ts,
+        text: message.text,
+        ...message.blocks ? { blocks: message.blocks } : {}
+      });
+    }
+  };
+}
+
+// src/assistant/lifecycle/user-message.ts
+function createUserMessageHandler(deps) {
+  const { options, feedbackBlock, sessionStrategy } = deps;
+  const taskDisplayMode = options.taskDisplayMode ?? "timeline";
+  const messageFormatter = resolveSlackMessageFormatter(
+    options.formatChatMarkdown ?? {}
+  );
+  const formatStreamError = options.formatStreamError ?? (() => DEFAULT_STREAM_ERROR_MESSAGE);
+  const showReasoning = options.showReasoning ?? false;
+  const showToolUsage = options.showToolUsage ?? true;
+  const showSubagentToolUsage = options.showSubagentToolUsage ?? false;
+  const showSubagentResultInTask = options.showSubagentResultInTask ?? false;
+  const timeoutMs = options.timeoutMs ?? 12e4;
+  return async (args) => {
+    const {
+      message,
+      client,
+      context,
+      logger,
+      sayStream,
+      setStatus,
+      setSuggestedPrompts,
+      setTitle,
+      getThreadContext,
+      saveThreadContext
+    } = args;
+    const parsed = parseSlackMessageActivityFromMessageEvent(message);
+    if (!parsed) {
+      return;
+    }
+    const { channel, threadTs, text, userId } = parsed;
+    const teamId = context.teamId ?? context.enterpriseId;
+    if (!channel || !threadTs || !text) {
+      return;
+    }
+    const diagnosticsLogger = options.logger ?? logger;
+    const auth = extractSlackAuthContext(context, userId);
+    const threadContext = await safeGetThreadContext(
+      getThreadContext,
+      diagnosticsLogger
+    );
+    const assistantUtilities = {
+      setStatus: async (update) => {
+        await setStatus(update);
+      },
+      setSuggestedPrompts: async (prompts) => {
+        await setSuggestedPrompts({
+          ...prompts.title ? { title: prompts.title } : {},
+          prompts: prompts.prompts
+        });
+      },
+      setTitle: async (title) => {
+        await setTitle(title);
+      },
+      getThreadContext: () => getThreadContext(),
+      saveThreadContext: () => saveThreadContext()
+    };
+    const initialSessionId = resolveAssistantSessionId(parsed, sessionStrategy);
+    const baseRequest = {
+      message: parsed,
+      sessionId: initialSessionId,
+      client,
+      rawArgs: args,
+      auth,
+      threadContext,
+      assistant: assistantUtilities
+    };
+    const sink = createAssistantSink({
+      client,
+      sayStream,
+      channel,
+      threadTs,
+      teamId,
+      userId,
+      taskDisplayMode,
+      ...options.chatStreamStartArgs ? { chatStreamStartArgs: options.chatStreamStartArgs } : {}
+    });
+    let translatedError;
+    let unsupportedInteractive;
+    let timeoutId;
+    try {
+      const initialStatus = await resolveInitialStatus(
+        options.initialStatus,
+        baseRequest
+      );
+      if (initialStatus) {
+        try {
+          await setStatus(initialStatus);
+        } catch (error) {
+          diagnosticsLogger.warn?.("setStatus failed", {
+            error: formatErrorForLog(error)
+          });
+        }
+      }
+      let sessionId = initialSessionId;
+      if (options.resolveSession) {
+        const resolved = await options.resolveSession(baseRequest);
+        if (resolved && resolved.length > 0) {
+          sessionId = resolved;
+        }
+      }
+      const turnPrep = await options.prepareTurn?.({ ...baseRequest, sessionId }) ?? {};
+      if (turnPrep.sessionId && turnPrep.sessionId.length > 0) {
+        sessionId = turnPrep.sessionId;
+      }
+      const turnMessage = turnPrep.message ?? text;
+      const userMessageRequest = {
+        ...baseRequest,
+        sessionId,
+        message: { ...parsed, text: turnMessage }
+      };
+      if (options.formatThreadTitle) {
+        try {
+          const title = await options.formatThreadTitle(userMessageRequest);
+          if (title) {
+            await setTitle(title);
+          }
+        } catch (error) {
+          diagnosticsLogger.warn?.("setTitle failed", {
+            error: formatErrorForLog(error)
+          });
+        }
+      }
+      const configuredFinalBlocks = Array.isArray(
+        options.chatStreamFinalArgs?.blocks
+      ) ? options.chatStreamFinalArgs.blocks : [];
+      const finalBlocks = feedbackBlock ? [...configuredFinalBlocks, feedbackBlock] : configuredFinalBlocks;
+      const chatStreamFinalArgs = options.chatStreamFinalArgs || finalBlocks.length > 0 ? {
+        ...options.chatStreamFinalArgs ?? {},
+        ...finalBlocks.length > 0 ? { blocks: finalBlocks } : {}
+      } : void 0;
+      const bridgeOptions = resolveSlackEventBridgeOptions({
+        streamingMode: "chat-stream",
+        showReasoning,
+        showToolUsage,
+        showSubagentToolUsage,
+        showSubagentResultInTask,
+        ...options.formatToolTitle ? { formatToolTitle: options.formatToolTitle } : {},
+        ...options.formatToolUpdate ? { formatToolUpdate: options.formatToolUpdate } : {},
+        ...options.formatToolDetails ? { formatToolDetails: options.formatToolDetails } : {},
+        ...options.formatToolError ? { formatToolError: options.formatToolError } : {},
+        ...options.formatReasoningUpdate ? { formatReasoningUpdate: options.formatReasoningUpdate } : {},
+        ...options.chatStreamBufferSize !== void 0 ? { chatStreamBufferSize: options.chatStreamBufferSize } : {},
+        ...options.maxTaskUpdates !== void 0 ? { maxTaskUpdates: options.maxTaskUpdates } : {},
+        ...options.maxTaskUpdateTextChars !== void 0 ? { maxTaskUpdateTextChars: options.maxTaskUpdateTextChars } : {},
+        ...options.maxTaskUpdateFieldChars !== void 0 ? { maxTaskUpdateFieldChars: options.maxTaskUpdateFieldChars } : {},
+        ...chatStreamFinalArgs ? { chatStreamFinalArgs } : {},
+        formatMessageText: messageFormatter,
+        onStatusChange: async (label, event) => {
+          const update = await resolveStatusUpdate(
+            options.formatStatus,
+            label,
+            event,
+            args
+          );
+          if (update) {
+            try {
+              await setStatus(update);
+            } catch (error) {
+              diagnosticsLogger.warn?.("setStatus failed", {
+                error: formatErrorForLog(error)
+              });
+            }
+          }
+        },
+        ...options.handleInteractiveRequest ? {
+          handleInteractiveRequest: (interactive) => options.handleInteractiveRequest({
+            ...interactive,
+            slackActivity: parsed,
+            user: {
+              userId: userId ?? "unknown",
+              channelId: channel,
+              ...teamId ? { teamId } : {},
+              threadTs,
+              ...parsed.messageTs ? { messageTs: parsed.messageTs } : {}
+            },
+            sessionId,
+            message: turnMessage,
+            responder: createAssistantInteractiveResponder({
+              client,
+              channel,
+              threadTs
+            })
+          })
+        } : {}
+      });
+      const abortController = new AbortController();
+      timeoutId = timeoutMs > 0 ? setTimeout(() => abortController.abort(), timeoutMs) : void 0;
+      await runWithSlackTurnContext(
+        {
+          slackActivity: parsed,
+          user: {
+            userId: userId ?? "unknown",
+            channelId: channel,
+            ...teamId ? { teamId } : {},
+            threadTs
+          },
+          sessionId,
+          message: turnMessage,
+          auth,
+          threadContext,
+          assistant: assistantUtilities,
+          ...turnPrep.context ? { context: turnPrep.context } : {}
+        },
+        () => withinScope(
+          {
+            kind: "activity",
+            name: turnPrep.scopeName?.trim() || "slack-assistant-activity",
+            sessionId,
+            attributes: buildAssistantScopeAttributes(
+              parsed,
+              auth,
+              threadContext,
+              turnPrep
+            )
+          },
+          async () => {
+            const events = options.source.chat(sessionId, turnMessage, {
+              abort: abortController.signal,
+              ...turnPrep.system ? { system: turnPrep.system } : {}
+            });
+            const translated = (async function* () {
+              try {
+                for await (const event of events) {
+                  if (event.type === "error") {
+                    translatedError = toError(
+                      event.error
+                    );
+                    yield {
+                      type: "text-delta",
+                      text: `
+
+${formatStreamError(translatedError)}`
+                    };
+                    yield { type: "complete" };
+                    return;
+                  }
+                  yield event;
+                }
+              } catch (error) {
+                if (error instanceof UnsupportedSlackInteractiveRequestError) {
+                  unsupportedInteractive = error;
+                  throw error;
+                }
+                translatedError = toError(error);
+                yield {
+                  type: "text-delta",
+                  text: `
+
+${formatStreamError(translatedError)}`
+                };
+                yield { type: "complete" };
+              }
+            })();
+            const finalText = await bridgeAgentEventsToSlack(
+              translated,
+              sink,
+              bridgeOptions
+            );
+            if (!translatedError && options.getFollowUpPrompts) {
+              try {
+                const followUps = await options.getFollowUpPrompts({
+                  ...userMessageRequest,
+                  finalText
+                });
+                if (followUps && followUps.prompts.length > 0) {
+                  await assistantUtilities.setSuggestedPrompts(followUps);
+                }
+              } catch (error) {
+                diagnosticsLogger.warn?.("getFollowUpPrompts failed", {
+                  error: formatErrorForLog(error)
+                });
+              }
+            }
+          }
+        )
+      );
+    } catch (error) {
+      if (error instanceof UnsupportedSlackInteractiveRequestError && !unsupportedInteractive) {
+        unsupportedInteractive = error;
+      }
+      if (!unsupportedInteractive) {
+        try {
+          await sink.appendError(formatStreamError(toError(error)));
+        } catch {
+        }
+      }
+      try {
+        await sink.finalize();
+      } catch {
+      }
+    } finally {
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+      }
+      try {
+        await setStatus({ status: "" });
+      } catch {
+      }
+      if (translatedError) {
+        logger.error(
+          `[channel-slack-agent-core] userMessage error surfaced to user: ${translatedError.message}`
+        );
+      }
+    }
+  };
+}
+
+// src/assistant/bridge.ts
+function createSlackAssistantBridge(options) {
+  if (!options.source || typeof options.source.chat !== "function") {
+    throw new Error(
+      "createSlackAssistantBridge: options.source must implement AgentTurnSource"
+    );
+  }
+  if (options.timeoutMs !== void 0 && (!Number.isFinite(options.timeoutMs) || options.timeoutMs < 0)) {
+    throw new Error(
+      "createSlackAssistantBridge: timeoutMs must be a finite non-negative number"
+    );
+  }
+  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 threadStarted = createThreadStartedHandler(options);
+  const threadContextChanged = createThreadContextChangedHandler();
+  const threadContextStore = options.threadContextStore ?? createSlackAssistantThreadContextStore();
+  const userMessage = createUserMessageHandler({
+    options,
+    feedbackBlock,
+    sessionStrategy
+  });
+  const config = {
+    threadStarted,
+    threadContextChanged,
+    userMessage,
+    // The store shape must match Bolt's `AssistantThreadContextStore` exactly.
+    // We accept the structural alias above and cast here so callers don't
+    // need to import Bolt's internal types in their own code.
+    threadContextStore
+  };
+  const assistant = new Assistant(config);
+  function install(app) {
+    app.assistant(assistant);
+    if (feedbackConfig) {
+      (0, feedback_exports.registerSlackFeedbackAction)(app, {
+        ...feedbackConfig,
+        resolveSessionId: (context) => resolveFeedbackSessionId(context, sessionStrategy),
+        onFeedback: feedbackConfig.onFeedback ?? (async (_ctx) => {
+        })
+      });
+    }
+  }
+  return {
+    assistant,
+    install,
+    ...feedbackConfig ? { feedbackActionId } : {}
+  };
+}
+
+export {
+  parseSlackMessageActivityFromMessageEvent,
+  resolveAssistantSessionId,
+  createSlackAssistantThreadContextStore,
+  createSlackAssistantBridge
+};