@cuylabs/channel-slack-agent-core 0.9.0 → 0.11.0

package/dist/chunk-XA7U3GRN.js

@@ -1,482 +0,0 @@
-import {
-  UnsupportedSlackInteractiveRequestError,
-  bridgeAgentEventsToSlack,
-  resolveSlackEventBridgeOptions
-} from "./chunk-VBGQD6JT.js";
-
-// src/adapter/adapter.ts
-import { withinScope } from "@cuylabs/agent-core";
-import {
-  extractSlackAuthContext,
-  extractSlackUserIdentity,
-  isProcessableMessage,
-  parseSlackMentionActivity,
-  parseSlackMessageActivity,
-  resolveSlackMessageFormatter,
-  runWithSlackTurnContext
-} 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") {
-    if (!options.resolveSessionId) {
-      throw new Error(
-        "SlackChannelOptions.resolveSessionId is required when sessionStrategy is 'custom'"
-      );
-    }
-    const customResolve = options.resolveSessionId;
-    return {
-      resolve(info) {
-        return customResolve(info);
-      }
-    };
-  }
-  if (strategy === "channel-id") {
-    return {
-      resolve(info) {
-        return info.channelId;
-      }
-    };
-  }
-  if (strategy === "user-per-channel") {
-    return {
-      resolve(info) {
-        return `${info.channelId}:${info.userId}`;
-      }
-    };
-  }
-  if (strategy === "user-per-thread") {
-    return {
-      resolve(info) {
-        if (info.channelType === "dm") {
-          return `${info.channelId}:${info.userId}`;
-        }
-        return `${info.channelId}:${info.threadTs ?? info.messageTs ?? info.channelId}:${info.userId}`;
-      }
-    };
-  }
-  return {
-    resolve: resolveThreadAwareSlackSessionId
-  };
-}
-
-// src/adapter/sink.ts
-function buildThreadPayload(info, respondInThread) {
-  if (!respondInThread || info.channelType === "dm") return {};
-  const threadTs = info.threadTs ?? info.messageTs;
-  return threadTs ? { thread_ts: threadTs } : {};
-}
-function buildResponseSink(say, client, info, respondInThread, chatStreamStartArgs, sayStream) {
-  const threadPayload = buildThreadPayload(info, respondInThread);
-  return {
-    artifactClient: client,
-    artifactTarget: {
-      channelId: info.channelId,
-      ...threadPayload.thread_ts ? { threadTs: threadPayload.thread_ts } : {}
-    },
-    async postMessage(text) {
-      const result = await say({ text, ...threadPayload });
-      const response = result;
-      const { channel, ts } = response;
-      if (!channel || !ts) {
-        throw new Error("Slack say() response did not include channel and ts.");
-      }
-      return { channel, ts };
-    },
-    async updateMessage(channel, ts, text) {
-      await client.chat.update({ channel, ts, text });
-    },
-    createChatStream({ bufferSize }) {
-      const threadTs = threadPayload.thread_ts ?? info.messageTs;
-      if (!threadTs) {
-        throw new Error(
-          "Slack chat-stream mode requires a source message timestamp."
-        );
-      }
-      const streamArgs = {
-        ...chatStreamStartArgs ?? {},
-        buffer_size: bufferSize
-      };
-      if (typeof sayStream === "function") {
-        return sayStream(streamArgs);
-      }
-      const streamer = client.chatStream({
-        channel: info.channelId,
-        thread_ts: threadTs,
-        ...info.teamId ? { recipient_team_id: info.teamId } : {},
-        recipient_user_id: info.userId,
-        ...streamArgs
-      });
-      return streamer;
-    }
-  };
-}
-function buildInteractiveResponder(say, client, info, respondInThread) {
-  const threadPayload = buildThreadPayload(info, respondInThread);
-  return {
-    async postMessage(message) {
-      const result = await say({
-        text: message.text,
-        ...message.blocks ? { blocks: message.blocks } : {},
-        ...threadPayload
-      });
-      const response = result;
-      const channel = response.channel ?? info.channelId;
-      const ts = response.ts;
-      if (!channel || !ts) {
-        throw new Error("Slack say() response did not include channel and ts.");
-      }
-      return { channel, ts };
-    },
-    async updateMessage(ref, message) {
-      await client.chat.update({
-        channel: ref.channel,
-        ts: ref.ts,
-        text: message.text,
-        ...message.blocks ? { blocks: message.blocks } : {}
-      });
-    }
-  };
-}
-
-// src/adapter/scope-attributes.ts
-function buildScopeAttributes(info, user, prep) {
-  return {
-    slackChannelId: info.channelId,
-    slackChannelType: info.channelType,
-    slackUserId: user.userId,
-    slackTeamId: user.teamId,
-    slackThreadTs: info.threadTs,
-    slackIsMention: info.isMention,
-    ...prep.scopeAttributes ?? {}
-  };
-}
-
-// src/adapter/adapter.ts
-var DEFAULT_CLASSIC_INITIAL_STATUS = {
-  status: "Thinking..."
-};
-function createSlackChannelAdapter(options) {
-  const source = resolveTurnSource(options);
-  const sessionMap = createSlackSessionMap(options);
-  const bridgeOptions = resolveSlackEventBridgeOptions(
-    {
-      showReasoning: options.showReasoning,
-      showToolUsage: options.showToolUsage,
-      showSubagentToolUsage: options.showSubagentToolUsage,
-      showSubagentResultInTask: options.showSubagentResultInTask,
-      formatToolTitle: options.formatToolTitle,
-      formatToolUpdate: options.formatToolUpdate,
-      formatToolDetails: options.formatToolDetails,
-      formatToolResultOutput: options.formatToolResultOutput,
-      formatToolError: options.formatToolError,
-      formatReasoningUpdate: options.formatReasoningUpdate,
-      interactiveMode: options.interactiveMode,
-      formatApprovalRequired: options.formatApprovalRequired,
-      formatHumanInputRequired: options.formatHumanInputRequired,
-      formatMessageText: resolveSlackMessageFormatter(options),
-      streamingMode: options.streamingMode,
-      progressiveUpdateThreshold: options.progressiveUpdateThreshold,
-      progressiveUpdateIntervalMs: options.progressiveUpdateIntervalMs,
-      chatStreamBufferSize: options.chatStreamBufferSize,
-      maxTaskUpdates: options.maxTaskUpdates,
-      maxTaskUpdateTextChars: options.maxTaskUpdateTextChars,
-      maxTaskUpdateFieldChars: options.maxTaskUpdateFieldChars,
-      chatStreamFinalArgs: options.chatStreamFinalArgs,
-      publishFinalResponseArtifact: options.publishFinalResponseArtifact,
-      finalResponseArtifactMode: options.finalResponseArtifactMode,
-      finalResponseArtifactStreamThreshold: options.finalResponseArtifactStreamThreshold,
-      formatFinalResponseArtifactContinuationNotice: options.formatFinalResponseArtifactContinuationNotice,
-      formatFinalResponseArtifactMessage: options.formatFinalResponseArtifactMessage,
-      onFinalResponseArtifactError: options.onFinalResponseArtifactError
-    }
-  );
-  const timeout = options.timeout ?? 12e4;
-  const respondInThread = options.respondInThread ?? true;
-  const respondToMentions = options.respondToMentions ?? true;
-  const respondToMessages = options.respondToMessages ?? true;
-  const respondToChannelMessages = options.respondToChannelMessages ?? false;
-  async function processTurn(slackActivity, say, client, context, utilities = {}) {
-    const rawText = slackActivity.text.trim();
-    const userText = options.resolveMessage ? await options.resolveMessage(slackActivity) : rawText;
-    if (!userText) return;
-    const initialSessionId = await sessionMap.resolve(slackActivity);
-    const userIdentity = extractSlackUserIdentity(slackActivity);
-    const auth = extractSlackAuthContext(context, slackActivity.userId);
-    const hasSayStream = typeof utilities.sayStream === "function";
-    const hasSetStatus = typeof utilities.setStatus === "function";
-    options.logger?.debug?.("slack classic turn utilities", {
-      channelId: slackActivity.channelId,
-      channelType: slackActivity.channelType,
-      isMention: slackActivity.isMention,
-      threadTs: slackActivity.threadTs,
-      messageTs: slackActivity.messageTs,
-      hasSayStream,
-      hasSetStatus
-    });
-    const baseTurnRequest = {
-      slackActivity,
-      user: userIdentity,
-      sessionId: initialSessionId,
-      message: userText,
-      auth,
-      ...utilities.setStatus ? { setStatus: utilities.setStatus } : {}
-    };
-    if (utilities.setStatus) {
-      const initialStatus = await resolveClassicInitialStatus(
-        options,
-        baseTurnRequest
-      );
-      if (initialStatus) {
-        try {
-          await utilities.setStatus(initialStatus);
-        } catch (error) {
-          options.logger?.warn?.("slack classic setStatus failed", {
-            error: formatErrorForLog(error)
-          });
-        }
-      }
-    }
-    const resolvedSessionId = await options.resolveSession?.(baseTurnRequest);
-    const sessionId = resolvedSessionId && resolvedSessionId.length > 0 ? resolvedSessionId : initialSessionId;
-    const turnRequest = {
-      ...baseTurnRequest,
-      sessionId
-    };
-    const preparedTurn = await resolveTurnPreparation(
-      options,
-      turnRequest,
-      userIdentity
-    );
-    const finalSessionId = preparedTurn.sessionId && preparedTurn.sessionId.length > 0 ? preparedTurn.sessionId : sessionId;
-    const finalUserText = preparedTurn.message ?? userText;
-    const sink = buildResponseSink(
-      say,
-      client,
-      slackActivity,
-      respondInThread,
-      options.chatStreamStartArgs,
-      utilities.sayStream
-    );
-    const abortController = new AbortController();
-    const chatOptions = {
-      abort: abortController.signal
-    };
-    if (preparedTurn.system) {
-      chatOptions.system = preparedTurn.system;
-    }
-    const timeoutId = timeout > 0 ? setTimeout(() => abortController.abort(), timeout) : void 0;
-    try {
-      const scopeAttributes = buildScopeAttributes(
-        slackActivity,
-        userIdentity,
-        preparedTurn
-      );
-      await runWithSlackTurnContext(
-        {
-          ...turnRequest,
-          sessionId: finalSessionId,
-          message: finalUserText,
-          ...utilities.setStatus ? { setStatus: utilities.setStatus } : {},
-          ...preparedTurn.context ? { context: preparedTurn.context } : {}
-        },
-        () => withinScope(
-          {
-            kind: "activity",
-            name: preparedTurn.scopeName?.trim() || "slack-activity",
-            sessionId: finalSessionId,
-            attributes: scopeAttributes
-          },
-          async () => {
-            const events = source.chat(
-              finalSessionId,
-              finalUserText,
-              chatOptions
-            );
-            const baseTurnBridgeOptions = options.handleInteractiveRequest ? {
-              ...bridgeOptions,
-              handleInteractiveRequest: (interactive) => options.handleInteractiveRequest({
-                ...interactive,
-                slackActivity,
-                user: userIdentity,
-                sessionId: finalSessionId,
-                message: finalUserText,
-                responder: buildInteractiveResponder(
-                  say,
-                  client,
-                  slackActivity,
-                  respondInThread
-                )
-              })
-            } : bridgeOptions;
-            const turnBridgeOptions = withClassicStatusUpdates(
-              baseTurnBridgeOptions,
-              utilities.setStatus
-            );
-            await bridgeAgentEventsToSlack(events, sink, turnBridgeOptions);
-          }
-        )
-      );
-    } catch (error) {
-      const errorInstance = error instanceof Error ? error : new Error(String(error));
-      if (!(errorInstance instanceof UnsupportedSlackInteractiveRequestError)) {
-        await say({
-          text: `I encountered an error while processing your request: ${errorInstance.message}`,
-          ...buildThreadPayload(slackActivity, respondInThread)
-        }).catch(() => void 0);
-      }
-      if (options.onError) {
-        await options.onError(errorInstance, slackActivity);
-      }
-    } finally {
-      if (timeoutId) {
-        clearTimeout(timeoutId);
-      }
-      if (utilities.setStatus) {
-        await utilities.setStatus({ status: "" }).catch(
-          (error) => options.logger?.warn?.("slack classic clear status failed", {
-            error: formatErrorForLog(error)
-          })
-        );
-      }
-    }
-  }
-  function mount(app) {
-    if (respondToMessages) {
-      app.message(
-        async ({
-          message,
-          say,
-          client,
-          context,
-          sayStream,
-          setStatus
-        }) => {
-          const raw = message;
-          if (!isProcessableMessage(
-            raw
-          )) {
-            return;
-          }
-          const info = parseSlackMessageActivity(
-            raw
-          );
-          if (info.channelType !== "dm" && !respondToChannelMessages) {
-            return;
-          }
-          if (!info.text) return;
-          await processTurn(info, say, client, context, {
-            ...typeof sayStream === "function" ? { sayStream } : {},
-            ...typeof setStatus === "function" ? { setStatus } : {}
-          });
-        }
-      );
-    }
-    if (respondToMentions) {
-      app.event(
-        "app_mention",
-        async ({
-          event,
-          say,
-          client,
-          context,
-          sayStream,
-          setStatus
-        }) => {
-          const info = parseSlackMentionActivity(
-            event
-          );
-          if (!info.text) return;
-          await processTurn(info, say, client, context, {
-            ...typeof sayStream === "function" ? { sayStream } : {},
-            ...typeof setStatus === "function" ? { setStatus } : {}
-          });
-        }
-      );
-    }
-    if (options.welcomeMessage != null) {
-      app.event("member_joined_channel", async ({ event, client }) => {
-        const channelId = event.channel;
-        const userId = event.user;
-        const botInfo = await client.auth.test().catch(() => void 0);
-        if (botInfo?.user_id === userId) return;
-        await client.chat.postMessage({
-          channel: userId,
-          // DM the new member
-          text: options.welcomeMessage
-        }).catch(() => void 0);
-        await client.chat.postMessage({
-          channel: channelId,
-          text: options.welcomeMessage
-        }).catch(() => void 0);
-      });
-    }
-  }
-  return {
-    mount,
-    getSessionId: (info) => sessionMap.resolve(info)
-  };
-}
-function formatClassicSlackStatusUpdate(status) {
-  return { status };
-}
-async function resolveClassicInitialStatus(options, request) {
-  if (options.initialStatus === void 0) {
-    return DEFAULT_CLASSIC_INITIAL_STATUS;
-  }
-  if (typeof options.initialStatus === "function") {
-    return await options.initialStatus(request) ?? void 0;
-  }
-  return options.initialStatus;
-}
-function withClassicStatusUpdates(options, setStatus) {
-  if (!setStatus) {
-    return options;
-  }
-  return {
-    ...options,
-    onStatusChange: async (label, event) => {
-      await options.onStatusChange?.(label, event);
-      await setStatus(formatClassicSlackStatusUpdate(label));
-    }
-  };
-}
-function resolveTurnSource(options) {
-  const hasAgent = options.agent !== void 0;
-  const hasSource = options.source !== void 0;
-  if (hasAgent === hasSource) {
-    throw new Error(
-      "Provide exactly one of SlackChannelOptions.agent or SlackChannelOptions.source."
-    );
-  }
-  if (options.source) return options.source;
-  if (options.agent) return options.agent;
-  throw new Error(
-    "Provide exactly one of SlackChannelOptions.agent or SlackChannelOptions.source."
-  );
-}
-async function resolveTurnPreparation(options, request, user) {
-  if (options.prepareTurn) {
-    return await options.prepareTurn(request) ?? {};
-  }
-  if (options.resolveUserContext) {
-    const ctx = await options.resolveUserContext(user);
-    return ctx ?? {};
-  }
-  return {};
-}
-function formatErrorForLog(error) {
-  if (error instanceof Error) {
-    return error.stack ?? error.message;
-  }
-  return String(error);
-}
-
-export {
-  createSlackSessionMap,
-  createSlackChannelAdapter
-};

package/dist/express-assistant.d.ts

@@ -1,106 +0,0 @@
-import { Server } from 'node:http';
-import { Application } from 'express';
-import { App, ExpressReceiver } from '@slack/bolt';
-import { CreateSlackBoltAppOptions } from '@cuylabs/channel-slack/transports/http';
-import { SlackDirectAuthOptions, SlackDirectAuthMode } from '@cuylabs/channel-slack/auth';
-import { C as CreateSlackAssistantBridgeOptions, d as SlackAssistantFeedbackConfig, S as SlackAssistantBridge } from './options-ByNm2o89.js';
-import { SlackFeedbackHandler } from '@cuylabs/channel-slack/feedback';
-import '@cuylabs/agent-core';
-import '@slack/web-api';
-import '@cuylabs/channel-slack/core';
-import './interactive-BigrPKnu.js';
-import '@cuylabs/channel-slack/interactive';
-import './options-CGUfVStV.js';
-import './artifacts/index.js';
-import '@cuylabs/channel-slack/artifacts';
-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

@@ -1,9 +0,0 @@
-import {
-  mountSlackAssistantAgent
-} from "./chunk-JU5R6JZG.js";
-import "./chunk-FJP6ZFUB.js";
-import "./chunk-ELR6MQD7.js";
-import "./chunk-VBGQD6JT.js";
-export {
-  mountSlackAssistantAgent
-};

package/dist/express.d.ts

@@ -1,103 +0,0 @@
-import * as _slack_bolt from '@slack/bolt';
-import { Server } from 'node:http';
-import { AgentTurnSource } from '@cuylabs/agent-core';
-import { Application } from 'express';
-import { c as createSlackChannelAdapter } from './adapter-vbqtraAr.js';
-import { a as SlackChannelOptions } from './types-BeGPexio.js';
-import { CreateSlackBoltAppOptions } from '@cuylabs/channel-slack/transports/http';
-import { SlackDirectAuthOptions, SlackDirectAuthMode } from '@cuylabs/channel-slack/auth';
-import '@cuylabs/channel-slack/core';
-import './options-CGUfVStV.js';
-import './artifacts/index.js';
-import '@cuylabs/channel-slack/artifacts';
-import './interactive-BigrPKnu.js';
-import '@cuylabs/channel-slack/interactive';
-
-interface MountSlackAgentOptions extends Omit<SlackChannelOptions, "agent" | "source">, 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.
-     *
-     * Use this for:
-     * - multi-workspace OAuth installs
-     * - custom Bolt authorize callbacks
-     *
-     * When omitted, `mountSlackAgent()` defaults to single-workspace mode
-     * using `botToken` / `SLACK_BOT_TOKEN`.
-     */
-    auth?: SlackDirectAuthOptions;
-    /**
-     * Exact Slack Events API callback path handled by Bolt.
-     *
-     * This becomes the request URL you configure in the Slack app:
-     * `https://<your-host>${path}`.
-     *
-     * @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/interface passed to `app.listen(port, host)`.
-     */
-    host?: string;
-    /**
-     * Pre-existing Express app. If not provided, a new one is created.
-     *
-     * When provided, the Bolt receiver router is mounted on `path` and no
-     * internal `app.listen()` is called (the caller must start the server).
-     */
-    app?: Application;
-}
-interface MountSlackAgentResult {
-    /** The Express application */
-    app: Application;
-    /** The Bolt App instance */
-    boltApp: _slack_bolt.App;
-    /** The Bolt ExpressReceiver */
-    receiver: _slack_bolt.ExpressReceiver;
-    /** Resolved direct Slack auth mode */
-    authMode: SlackDirectAuthMode;
-    /** Exact Slack callback path handled by Bolt */
-    routePath: string;
-    /** The Slack channel adapter */
-    channelAdapter: ReturnType<typeof createSlackChannelAdapter>;
-    /** The Node HTTP server when `listen()` was started internally */
-    server?: Server;
-}
-/**
- * Mount an agent-core-compatible turn source as a Slack bot on an Express app.
- *
- * This is the simplest way to deploy an agent-core agent to Slack. It handles:
- * 1. Creating a Bolt `ExpressReceiver` with request verification.
- * 2. Creating a Bolt `App` using one of the supported direct auth modes.
- * 3. Creating the Slack channel adapter and mounting it on the Bolt App.
- * 4. Registering `receiver.router` on the Express app.
- * 5. Optionally starting the server.
- *
- * Single-workspace mode environment variables (if not passed explicitly):
- * - `SLACK_BOT_TOKEN` — Bot OAuth token (`xoxb-...`)
- * - `SLACK_SIGNING_SECRET` — App signing secret for request verification
- *
- * OAuth mode environment variables:
- * - `SLACK_SIGNING_SECRET`
- * - `SLACK_CLIENT_ID`
- * - `SLACK_CLIENT_SECRET`
- * - `SLACK_STATE_SECRET` unless you provide a custom state store
- */
-declare function mountSlackAgent(source: AgentTurnSource, options?: MountSlackAgentOptions): Promise<MountSlackAgentResult>;
-
-export { type MountSlackAgentOptions, type MountSlackAgentResult, mountSlackAgent };