@cuylabs/channel-slack-agent-core 0.1.0

package/dist/chunk-JMLB7A2V.js

@@ -0,0 +1,85 @@
+import {
+  createSlackAssistantBridge
+} from "./chunk-BFUPAJON.js";
+import {
+  bolt_exports
+} from "./chunk-ANIZ5NT4.js";
+
+// src/express-assistant.ts
+async function mountSlackAssistantAgent(options) {
+  const {
+    botToken,
+    signingSecret,
+    auth,
+    path,
+    processBeforeResponse,
+    signatureVerification,
+    boltAppOptions,
+    receiverOptions,
+    port: portOption,
+    host,
+    app: providedApp,
+    feedback: feedbackOption,
+    onFeedback,
+    ...bridgeOptions
+  } = options;
+  const {
+    boltApp,
+    receiver,
+    app: expressApp,
+    authMode,
+    routePath
+  } = await (0, bolt_exports.createSlackBoltApp)({
+    signingSecret,
+    path,
+    botToken,
+    auth,
+    app: providedApp,
+    processBeforeResponse,
+    signatureVerification,
+    boltAppOptions,
+    receiverOptions
+  });
+  const feedback = feedbackOption !== void 0 ? feedbackOption : onFeedback ? { onFeedback } : void 0;
+  const bridge = createSlackAssistantBridge({
+    ...bridgeOptions,
+    ...feedback !== void 0 ? { feedback } : {}
+  });
+  bridge.install(boltApp);
+  mountReceiverRouter(expressApp, receiver);
+  const port = portOption === void 0 ? resolvePort(process.env.PORT) : portOption;
+  let server;
+  if (!providedApp && port !== null) {
+    const onListen = () => {
+      process.stdout.write(
+        `Slack assistant listening on port ${port} at ${routePath}
+`
+      );
+    };
+    server = host ? expressApp.listen(port, host, onListen) : expressApp.listen(port, onListen);
+  }
+  return {
+    app: expressApp,
+    boltApp,
+    receiver,
+    authMode,
+    routePath,
+    bridge,
+    ...server ? { server } : {}
+  };
+}
+function resolvePort(port) {
+  if (!port) return 3e3;
+  const parsed = Number(port);
+  if (!Number.isInteger(parsed) || parsed < 0) {
+    throw new Error(`Invalid PORT value: ${port}`);
+  }
+  return parsed;
+}
+function mountReceiverRouter(app, receiver) {
+  app.use(receiver.router);
+}
+
+export {
+  mountSlackAssistantAgent
+};

package/dist/chunk-K2E6A377.js

@@ -0,0 +1,12 @@
+import {
+  __reExport
+} from "./chunk-I2KLQ2HA.js";
+
+// src/targets/index.ts
+var targets_exports = {};
+__reExport(targets_exports, targets_star);
+import * as targets_star from "@cuylabs/channel-slack/targets";
+
+export {
+  targets_exports
+};

package/dist/chunk-M64Z6TYL.js

@@ -0,0 +1,198 @@
+import {
+  createSlackAssistantBridge
+} from "./chunk-BFUPAJON.js";
+import {
+  feedback_exports
+} from "./chunk-VHGV66M7.js";
+import {
+  createSlackChannelAdapter
+} from "./chunk-FDRQOG7Q.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 installSlackAgentAppSurface(boltApp, options) {
+  const {
+    respondToMentions,
+    respondToMessages,
+    respondToChannelMessages,
+    resolveMessage,
+    feedback: feedbackOption,
+    onFeedback,
+    timeoutMs,
+    logger,
+    source,
+    prepareTurn,
+    resolveSession,
+    interactive,
+    ...assistantBridgeOptions
+  } = options;
+  const feedbackConfig = feedbackOption === false ? void 0 : feedbackOption ?? (onFeedback ? { onFeedback } : {});
+  const assistantFeedback = feedbackOption === false ? false : feedbackConfig;
+  const feedbackBlock = feedbackConfig ? (0, feedback_exports.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 } : {}
+  });
+  boltApp.assistant(bridge.assistant);
+  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,
+    formatToolError: assistantBridgeOptions.formatToolError,
+    formatReasoningUpdate: assistantBridgeOptions.formatReasoningUpdate,
+    chatStreamBufferSize: assistantBridgeOptions.chatStreamBufferSize,
+    chatStreamStartArgs: {
+      ...assistantBridgeOptions.chatStreamStartArgs ?? {},
+      task_display_mode: assistantBridgeOptions.taskDisplayMode ?? "timeline"
+    },
+    ...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);
+  if (feedbackConfig) {
+    const feedbackSessionStrategy = assistantBridgeOptions.sessionStrategy ?? "thread-aware";
+    (0, feedback_exports.registerSlackFeedbackAction)(boltApp, {
+      ...feedbackConfig,
+      resolveSessionId: (ctx) => resolveFeedbackSessionId(ctx, feedbackSessionStrategy),
+      onFeedback: feedbackConfig.onFeedback ?? (async (_ctx) => {
+      })
+    });
+  }
+  interactive?.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);
+}
+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}`;
+  }
+}
+
+export {
+  installSlackAgentAppSurface
+};

package/dist/chunk-NDVXBI7Z.js

@@ -0,0 +1,12 @@
+import {
+  __reExport
+} from "./chunk-I2KLQ2HA.js";
+
+// src/diagnostics/index.ts
+var diagnostics_exports = {};
+__reExport(diagnostics_exports, diagnostics_star);
+import * as diagnostics_star from "@cuylabs/channel-slack/diagnostics";
+
+export {
+  diagnostics_exports
+};

package/dist/chunk-NIPAN4KA.js

@@ -0,0 +1,76 @@
+import {
+  currentSlackTurnContext
+} from "./chunk-DHPD4XH5.js";
+
+// src/shared/context-fragments.ts
+var DEFAULT_SLACK_CONTEXT_FRAGMENT_KEY = "slackContextFragment";
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function isPayload(value) {
+  return isRecord(value) && typeof value.content === "string";
+}
+function resolveContextBagValue(slack, key) {
+  const value = slack.context?.[key];
+  if (typeof value === "string") {
+    return value;
+  }
+  if (isPayload(value)) {
+    return value;
+  }
+  return void 0;
+}
+function resolveDedupeKey(options, context) {
+  return typeof options.dedupeKey === "function" ? options.dedupeKey(context) : options.dedupeKey;
+}
+function resolveMetadata(options, context) {
+  return typeof options.metadata === "function" ? options.metadata(context) : options.metadata;
+}
+function normalizeFragment(resolved, options, context) {
+  const payload = typeof resolved === "string" ? { content: resolved } : isPayload(resolved) ? resolved : void 0;
+  if (!payload) {
+    return resolved;
+  }
+  if (payload.content.trim().length === 0) {
+    return void 0;
+  }
+  const dedupeKey = payload.dedupeKey ?? resolveDedupeKey(options, context);
+  const metadata = payload.metadata ?? resolveMetadata(options, context);
+  const maxChars = payload.maxChars ?? options.maxChars;
+  return {
+    kind: payload.kind ?? options.kind ?? "slack-context",
+    content: payload.content,
+    role: payload.role ?? options.role ?? "user",
+    placement: payload.placement ?? options.placement ?? "after-latest-user",
+    lifetime: payload.lifetime ?? options.lifetime ?? "turn",
+    source: payload.source ?? options.source ?? "slack",
+    title: payload.title ?? options.title ?? "Slack Context",
+    budgetBehavior: payload.budgetBehavior ?? options.budgetBehavior ?? "droppable",
+    ...maxChars !== void 0 ? { maxChars } : {},
+    ...dedupeKey ? { dedupeKey } : {},
+    ...metadata ? { metadata } : {}
+  };
+}
+function createSlackContextFragmentMiddleware(options = {}) {
+  const contextKey = options.contextKey ?? DEFAULT_SLACK_CONTEXT_FRAGMENT_KEY;
+  return {
+    name: options.name ?? "slack-context-fragment",
+    async contextFragments(step) {
+      const slack = currentSlackTurnContext();
+      if (!slack) {
+        return void 0;
+      }
+      const context = { slack, step };
+      const resolved = options.resolve ? await options.resolve(context) : resolveContextBagValue(slack, contextKey);
+      if (resolved === void 0) {
+        return void 0;
+      }
+      return normalizeFragment(resolved, options, context);
+    }
+  };
+}
+
+export {
+  DEFAULT_SLACK_CONTEXT_FRAGMENT_KEY,
+  createSlackContextFragmentMiddleware
+};

package/dist/chunk-PX4RGO3N.js

@@ -0,0 +1,12 @@
+import {
+  __reExport
+} from "./chunk-I2KLQ2HA.js";
+
+// src/history/index.ts
+var history_exports = {};
+__reExport(history_exports, history_star);
+import * as history_star from "@cuylabs/channel-slack/history";
+
+export {
+  history_exports
+};

package/dist/chunk-RFHXERNL.js

@@ -0,0 +1,27 @@
+// src/mcp.ts
+var SLACK_MCP_URL = "https://mcp.slack.com/mcp";
+function createSlackMcpServerConfig(options) {
+  const userToken = options.userToken.trim();
+  if (!userToken) {
+    throw new Error(
+      "createSlackMcpServerConfig: userToken is required (Slack user OAuth token)."
+    );
+  }
+  const headers = {
+    ...options.headers ?? {},
+    Authorization: `Bearer ${userToken}`
+  };
+  return {
+    transport: "http",
+    url: options.url ?? SLACK_MCP_URL,
+    headers,
+    ...options.timeout !== void 0 ? { timeout: options.timeout } : {},
+    ...options.enabled !== void 0 ? { enabled: options.enabled } : {},
+    ...options.name !== void 0 ? { name: options.name } : {}
+  };
+}
+
+export {
+  SLACK_MCP_URL,
+  createSlackMcpServerConfig
+};

package/dist/chunk-VHGV66M7.js

@@ -0,0 +1,12 @@
+import {
+  __reExport
+} from "./chunk-I2KLQ2HA.js";
+
+// src/feedback/index.ts
+var feedback_exports = {};
+__reExport(feedback_exports, feedback_star);
+import * as feedback_star from "@cuylabs/channel-slack/feedback";
+
+export {
+  feedback_exports
+};

package/dist/chunk-WO4BJMF3.js

@@ -0,0 +1,82 @@
+import {
+  createSlackChannelAdapter
+} from "./chunk-FDRQOG7Q.js";
+import {
+  bolt_exports
+} from "./chunk-ANIZ5NT4.js";
+
+// src/express.ts
+async function mountSlackAgent(source, options = {}) {
+  const {
+    botToken: providedToken,
+    signingSecret,
+    auth,
+    path,
+    processBeforeResponse,
+    signatureVerification,
+    boltAppOptions,
+    receiverOptions,
+    port: portOption,
+    host,
+    app: providedApp,
+    ...adapterOptions
+  } = options;
+  const {
+    boltApp,
+    receiver,
+    app: expressApp,
+    authMode,
+    routePath
+  } = await (0, bolt_exports.createSlackBoltApp)({
+    signingSecret,
+    path,
+    botToken: providedToken,
+    auth,
+    app: providedApp,
+    processBeforeResponse,
+    signatureVerification,
+    boltAppOptions,
+    receiverOptions
+  });
+  const channelAdapter = createSlackChannelAdapter({
+    source,
+    ...adapterOptions
+  });
+  channelAdapter.mount(boltApp);
+  mountReceiverRouter(expressApp, receiver);
+  const port = portOption === void 0 ? resolvePort(process.env.PORT) : portOption;
+  let server;
+  if (!providedApp && port !== null) {
+    const onListen = () => {
+      process.stdout.write(
+        `Slack bot listening on port ${port} at ${routePath}
+`
+      );
+    };
+    server = host ? expressApp.listen(port, host, onListen) : expressApp.listen(port, onListen);
+  }
+  return {
+    app: expressApp,
+    boltApp,
+    receiver,
+    authMode,
+    routePath,
+    channelAdapter,
+    server
+  };
+}
+function resolvePort(port) {
+  if (!port) return 3e3;
+  const parsed = Number(port);
+  if (!Number.isInteger(parsed) || parsed < 0) {
+    throw new Error(`Invalid PORT value: ${port}`);
+  }
+  return parsed;
+}
+function mountReceiverRouter(app, receiver) {
+  app.use(receiver.router);
+}
+
+export {
+  mountSlackAgent
+};

package/dist/diagnostics.d.ts

@@ -0,0 +1 @@
+export * from '@cuylabs/channel-slack/diagnostics';

package/dist/diagnostics.js

@@ -0,0 +1,10 @@
+import {
+  diagnostics_exports
+} from "./chunk-NDVXBI7Z.js";
+import {
+  __reExport
+} from "./chunk-I2KLQ2HA.js";
+
+// src/diagnostics.ts
+var diagnostics_exports2 = {};
+__reExport(diagnostics_exports2, diagnostics_exports);

package/dist/express-assistant.d.ts

@@ -0,0 +1,102 @@
+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 { 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';
+import '@slack/web-api';
+import '@cuylabs/channel-slack/core';
+import './interactive-o_NZb-Xg.js';
+import './options-C7OYeNR-.js';
+import '@cuylabs/channel-slack/assistant';
+
+/**
+ * Express helper for mounting the Slack assistant bridge.
+ *
+ * Companion to `mountSlackAgent` (which wires the classic
+ * `app.message`/`app.event` listeners). This one uses
+ * `createSlackAssistantBridge` so the bot uses Bolt's
+ * `app.assistant(new Assistant({...}))` lifecycle — `setStatus`,
+ * `setSuggestedPrompts`, `chatStream`, feedback buttons.
+ *
+ * @example
+ * ```ts
+ * import { mountSlackAssistantAgent } from "@cuylabs/channel-slack-agent-core";
+ *
+ * await mountSlackAssistantAgent(agent, {
+ *   getSuggestedPrompts: () => ({
+ *     title: "Try one of these:",
+ *     prompts: [
+ *       { title: "Roll some dice", message: "Roll 2d20" },
+ *       { title: "Summarize this thread", message: "Summarize the last 20 messages" },
+ *     ],
+ *   }),
+ *   onFeedback: ({ verdict, sessionId }) => {
+ *     metrics.increment(`feedback.${verdict}`, { sessionId });
+ *   },
+ * });
+ * ```
+ */
+
+interface MountSlackAssistantAgentOptions extends Omit<CreateSlackAssistantBridgeOptions, "feedback">, Omit<CreateSlackBoltAppOptions, "app" | "path" | "botToken" | "signingSecret" | "auth"> {
+    /**
+     * Slack bot token (`xoxb-...`).
+     * @default process.env.SLACK_BOT_TOKEN
+     */
+    botToken?: string;
+    /**
+     * Slack signing secret used to verify incoming webhook requests.
+     * @default process.env.SLACK_SIGNING_SECRET
+     */
+    signingSecret?: string;
+    /**
+     * Structured direct-mode auth config (single-workspace, OAuth, custom).
+     * Defaults to `botToken` / `SLACK_BOT_TOKEN` single-workspace mode.
+     */
+    auth?: SlackDirectAuthOptions;
+    /**
+     * Slack Events API callback path handled by Bolt.
+     *
+     * @default "/slack/events"
+     */
+    path?: string;
+    /**
+     * Port to listen on. Set to `null` to skip `app.listen()` — caller manages
+     * the server.
+     *
+     * @default process.env.PORT || 3000
+     */
+    port?: number | null;
+    /** Optional host passed to `app.listen(port, host)`. */
+    host?: string;
+    /**
+     * Pre-existing Express app. If not provided, a new one is created and the
+     * helper calls `app.listen()` itself.
+     */
+    app?: Application;
+    /**
+     * Feedback config — block + handler. Pass `false` to omit feedback buttons
+     * entirely. Pass an object to override action ids, button labels, or the
+     * feedback handler. Pass a function as `onFeedback` for the most common
+     * case where only the handler differs.
+     */
+    feedback?: SlackAssistantFeedbackConfig | false;
+    /**
+     * Convenience shorthand: `onFeedback: handler` is equivalent to
+     * `feedback: { onFeedback: handler }`. Ignored if `feedback` is set.
+     */
+    onFeedback?: SlackFeedbackHandler;
+}
+interface MountSlackAssistantAgentResult {
+    app: Application;
+    boltApp: App;
+    receiver: ExpressReceiver;
+    authMode: SlackDirectAuthMode;
+    routePath: string;
+    bridge: SlackAssistantBridge;
+    server?: Server;
+}
+declare function mountSlackAssistantAgent(options: MountSlackAssistantAgentOptions): Promise<MountSlackAssistantAgentResult>;
+
+export { type MountSlackAssistantAgentOptions, type MountSlackAssistantAgentResult, mountSlackAssistantAgent };

package/dist/express-assistant.js

@@ -0,0 +1,12 @@
+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";
+export {
+  mountSlackAssistantAgent
+};