@cuylabs/channel-slack-agent-core 0.1.0

package/dist/express.d.ts

@@ -0,0 +1,98 @@
+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-Cmd2C90g.js';
+import { a as SlackChannelOptions } from './types-BqRzb_Cd.js';
+import { CreateSlackBoltAppOptions, SlackDirectAuthOptions, SlackDirectAuthMode } from '@cuylabs/channel-slack/bolt';
+import '@cuylabs/channel-slack/core';
+import './interactive-o_NZb-Xg.js';
+
+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 };

package/dist/express.js

@@ -0,0 +1,11 @@
+import {
+  mountSlackAgent
+} from "./chunk-WO4BJMF3.js";
+import "./chunk-FDRQOG7Q.js";
+import "./chunk-GNXWTKQ6.js";
+import "./chunk-DHPD4XH5.js";
+import "./chunk-ANIZ5NT4.js";
+import "./chunk-I2KLQ2HA.js";
+export {
+  mountSlackAgent
+};

package/dist/feedback.d.ts

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

package/dist/feedback.js

@@ -0,0 +1,10 @@
+import {
+  feedback_exports
+} from "./chunk-VHGV66M7.js";
+import {
+  __reExport
+} from "./chunk-I2KLQ2HA.js";
+
+// src/feedback.ts
+var feedback_exports2 = {};
+__reExport(feedback_exports2, feedback_exports);

package/dist/history.d.ts

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

package/dist/history.js

@@ -0,0 +1,10 @@
+import {
+  history_exports
+} from "./chunk-PX4RGO3N.js";
+import {
+  __reExport
+} from "./chunk-I2KLQ2HA.js";
+
+// src/history.ts
+var history_exports2 = {};
+__reExport(history_exports2, history_exports);

package/dist/index.d.ts

@@ -0,0 +1,32 @@
+export { ExtractSlackMessageTextOptions, RawSlackActionTokenPayload, RawSlackAppMentionPayload, RawSlackAssistantThreadPayload, RawSlackMessagePayload, SlackActivityInfo, SlackAmbientTurnContext, SlackAssistantStatusUpdate, SlackAssistantSuggestedPrompt, SlackAssistantSuggestedPrompts, SlackAssistantTaskDisplayMode, SlackAssistantThreadContext, SlackAssistantUtilities, SlackAuthContext, SlackChannelType, SlackChatStreamStartArgs, SlackMessageAuthorshipOptions, SlackMessageFormatter, SlackMessageFormattingOptions, SlackMessageTextPayload, SlackThreadStatusSetter, SlackTurnPreparation, SlackTurnRequestContext, SlackUserIdentity, currentSlackTurnContext, extractSlackActionToken, extractSlackAttachmentsText, extractSlackAuthContext, extractSlackBlocksText, extractSlackMessageText, extractSlackUserIdentity, formatSlackAttributedFollowUp, isProcessableMessage, markdownToSlackMrkdwn, parseSlackMentionActivity, parseSlackMessageActivity, resolveSlackChannelType, resolveSlackMessageFormatter, resolveThreadAwareSlackSessionId, runWithSlackTurnContext, stripLeadingMentions } from '@cuylabs/channel-slack/core';
+export { S as SlackApprovalRequest, a as SlackEventInteractiveRequestHandler, b as SlackHumanInputRequest, c as SlackInteractiveMessage, d as SlackInteractiveMessageRef, e as SlackInteractiveRequest, f as SlackInteractiveRequestBaseContext, g as SlackInteractiveRequestContext, h as SlackInteractiveRequestHandler, i as SlackInteractiveRequestKind, j as SlackInteractiveResponder } from './interactive-o_NZb-Xg.js';
+export { DEFAULT_SLACK_CONTEXT_FRAGMENT_KEY, SlackChatStream, SlackContextFragmentMiddlewareOptions, SlackContextFragmentPayload, SlackContextFragmentResolver, SlackContextFragmentResolverContext, SlackResponseSink, SlackStreamChunk, SlackStreamTaskStatus, UnsupportedSlackInteractiveRequestError, bridgeAgentEventsToSlack, createSlackContextFragmentMiddleware } from './shared.js';
+export { S as SlackEventBridgeOptions, r as resolveSlackEventBridgeOptions } from './options-C7OYeNR-.js';
+export * from '@cuylabs/channel-slack/bolt';
+export { c as createSlackChannelAdapter } from './adapter-Cmd2C90g.js';
+export { S as SlackChannelAdapter, a as SlackChannelOptions, b as SlackSessionStrategy, c as SlackStreamingMode, d as SlackToolStartEvent } from './types-BqRzb_Cd.js';
+export { SlackSessionMap, createSlackSessionMap } from './adapter.js';
+export { createSlackAssistantBridge } from './assistant.js';
+export { A as AssistantLifecycleArgs, a as AssistantThreadStartedArgs, C as CreateSlackAssistantBridgeOptions, M as MaybePromise, S as SlackAssistantBridge, b as SlackAssistantFeedbackConfig, c as SlackAssistantSessionStrategy, d as SlackAssistantStatusContext, e as SlackAssistantThreadContextStoreLike, f as SlackAssistantThreadStartedContext, g as SlackAssistantTurnPreparation, h as SlackAssistantUserMessageContext, r as resolveAssistantSessionId } from './options-Uf-qmQKN.js';
+export { ParsedAssistantUserMessage, createSlackAssistantThreadContextStore, parseSlackMessageActivityFromMessageEvent } from '@cuylabs/channel-slack/assistant';
+export * from '@cuylabs/channel-slack/history';
+export { S as SlackInteractiveActionIds, a as SlackInteractiveActor, b as SlackInteractiveApprovalRequest, c as SlackInteractiveController, d as SlackInteractiveControllerOptions, e as SlackInteractiveHumanInputRequest, f as SlackInteractiveMessageTarget, g as SlackInteractivePendingWaiter, h as SlackInteractivePostedMessage, i as SlackInteractiveRequestRecord, j as SlackInteractiveRequestStatus, k as SlackInteractiveRequestStore, l as SlackInteractiveRequestWaitOptions, m as SlackInteractiveResolution, n as SlackInteractiveStoredRequest } from './types-Crpil4kb.js';
+export { buildApprovalRequestMessage, buildHumanInputModal, buildHumanInputRequestMessage, buildResolvedMessage, cloneRecord, createInMemorySlackInteractiveRequestStore, createSlackInteractiveController, decodeActionValue, encodeActionValue, nowIso } from './interactive.js';
+export * from '@cuylabs/channel-slack/policy';
+export * from '@cuylabs/channel-slack/users';
+export * from '@cuylabs/channel-slack/diagnostics';
+export * from '@cuylabs/channel-slack/setup';
+export * from '@cuylabs/channel-slack/targets';
+export { MountSlackAgentOptions, MountSlackAgentResult, mountSlackAgent } from './express.js';
+export { MountSlackAssistantAgentOptions, MountSlackAssistantAgentResult, mountSlackAssistantAgent } from './express-assistant.js';
+export { MountSlackAgentAppSocketOptions, MountSlackAgentAppSocketResult, MountSlackAssistantAgentSocketOptions, MountSlackAssistantAgentSocketResult, mountSlackAgentAppSocket, mountSlackAssistantAgentSocket } from './socket.js';
+export { MountSlackAgentAppOptions, MountSlackAgentAppResult, mountSlackAgentApp } from './app.js';
+export { CreateSlackMcpServerConfigOptions, SLACK_MCP_URL, createSlackMcpServerConfig } from './mcp.js';
+export { MountSlackAgentAppTurnRequestContext } from './app-surface.js';
+import '@cuylabs/agent-core';
+import '@slack/bolt';
+import '@slack/web-api';
+import '@cuylabs/channel-slack/feedback';
+import 'node:http';
+import 'express';
+import '@cuylabs/agent-core/mcp';

package/dist/index.js

@@ -0,0 +1,202 @@
+import {
+  mountSlackAgentAppSocket,
+  mountSlackAssistantAgentSocket
+} from "./chunk-IWUYIAY5.js";
+import {
+  targets_exports
+} from "./chunk-K2E6A377.js";
+import {
+  users_exports
+} from "./chunk-HFT2FXJP.js";
+import {
+  history_exports
+} from "./chunk-PX4RGO3N.js";
+import {
+  buildApprovalRequestMessage,
+  buildHumanInputModal,
+  buildHumanInputRequestMessage,
+  buildResolvedMessage,
+  cloneRecord,
+  createInMemorySlackInteractiveRequestStore,
+  createSlackInteractiveController,
+  decodeActionValue,
+  encodeActionValue,
+  nowIso
+} from "./chunk-IXY3BXU5.js";
+import {
+  SLACK_MCP_URL,
+  createSlackMcpServerConfig
+} from "./chunk-RFHXERNL.js";
+import {
+  policy_exports
+} from "./chunk-2SUAW6MV.js";
+import {
+  setup_exports
+} from "./chunk-645NNJIM.js";
+import {
+  DEFAULT_SLACK_CONTEXT_FRAGMENT_KEY,
+  createSlackContextFragmentMiddleware
+} from "./chunk-NIPAN4KA.js";
+import {
+  mountSlackAgentApp
+} from "./chunk-CYEBGC6G.js";
+import "./chunk-M64Z6TYL.js";
+import {
+  diagnostics_exports
+} from "./chunk-NDVXBI7Z.js";
+import {
+  mountSlackAssistantAgent
+} from "./chunk-JMLB7A2V.js";
+import {
+  createSlackAssistantBridge,
+  createSlackAssistantThreadContextStore,
+  parseSlackMessageActivityFromMessageEvent,
+  resolveAssistantSessionId
+} from "./chunk-BFUPAJON.js";
+import "./chunk-VHGV66M7.js";
+import {
+  mountSlackAgent
+} from "./chunk-WO4BJMF3.js";
+import {
+  createSlackChannelAdapter,
+  createSlackSessionMap,
+  resolveThreadAwareSlackSessionId
+} from "./chunk-FDRQOG7Q.js";
+import {
+  extractSlackActionToken,
+  extractSlackAttachmentsText,
+  extractSlackAuthContext,
+  extractSlackBlocksText,
+  extractSlackMessageText,
+  extractSlackUserIdentity,
+  isProcessableMessage,
+  markdownToSlackMrkdwn,
+  parseSlackMentionActivity,
+  parseSlackMessageActivity,
+  resolveSlackChannelType,
+  resolveSlackMessageFormatter,
+  stripLeadingMentions
+} from "./chunk-GNXWTKQ6.js";
+import {
+  UnsupportedSlackInteractiveRequestError,
+  bridgeAgentEventsToSlack,
+  currentSlackTurnContext,
+  resolveSlackEventBridgeOptions,
+  runWithSlackTurnContext
+} from "./chunk-DHPD4XH5.js";
+import {
+  bolt_exports
+} from "./chunk-ANIZ5NT4.js";
+import {
+  __export,
+  __reExport
+} from "./chunk-I2KLQ2HA.js";
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  DEFAULT_SLACK_CONTEXT_FRAGMENT_KEY: () => DEFAULT_SLACK_CONTEXT_FRAGMENT_KEY,
+  SLACK_MCP_URL: () => SLACK_MCP_URL,
+  UnsupportedSlackInteractiveRequestError: () => UnsupportedSlackInteractiveRequestError,
+  bridgeAgentEventsToSlack: () => bridgeAgentEventsToSlack,
+  buildApprovalRequestMessage: () => buildApprovalRequestMessage,
+  buildHumanInputModal: () => buildHumanInputModal,
+  buildHumanInputRequestMessage: () => buildHumanInputRequestMessage,
+  buildResolvedMessage: () => buildResolvedMessage,
+  cloneRecord: () => cloneRecord,
+  createInMemorySlackInteractiveRequestStore: () => createInMemorySlackInteractiveRequestStore,
+  createSlackAssistantBridge: () => createSlackAssistantBridge,
+  createSlackAssistantThreadContextStore: () => createSlackAssistantThreadContextStore,
+  createSlackChannelAdapter: () => createSlackChannelAdapter,
+  createSlackContextFragmentMiddleware: () => createSlackContextFragmentMiddleware,
+  createSlackInteractiveController: () => createSlackInteractiveController,
+  createSlackMcpServerConfig: () => createSlackMcpServerConfig,
+  createSlackSessionMap: () => createSlackSessionMap,
+  currentSlackTurnContext: () => currentSlackTurnContext,
+  decodeActionValue: () => decodeActionValue,
+  encodeActionValue: () => encodeActionValue,
+  extractSlackActionToken: () => extractSlackActionToken,
+  extractSlackAttachmentsText: () => extractSlackAttachmentsText,
+  extractSlackAuthContext: () => extractSlackAuthContext,
+  extractSlackBlocksText: () => extractSlackBlocksText,
+  extractSlackMessageText: () => extractSlackMessageText,
+  extractSlackUserIdentity: () => extractSlackUserIdentity,
+  formatSlackAttributedFollowUp: () => formatSlackAttributedFollowUp,
+  isProcessableMessage: () => isProcessableMessage,
+  markdownToSlackMrkdwn: () => markdownToSlackMrkdwn,
+  mountSlackAgent: () => mountSlackAgent,
+  mountSlackAgentApp: () => mountSlackAgentApp,
+  mountSlackAgentAppSocket: () => mountSlackAgentAppSocket,
+  mountSlackAssistantAgent: () => mountSlackAssistantAgent,
+  mountSlackAssistantAgentSocket: () => mountSlackAssistantAgentSocket,
+  nowIso: () => nowIso,
+  parseSlackMentionActivity: () => parseSlackMentionActivity,
+  parseSlackMessageActivity: () => parseSlackMessageActivity,
+  parseSlackMessageActivityFromMessageEvent: () => parseSlackMessageActivityFromMessageEvent,
+  resolveAssistantSessionId: () => resolveAssistantSessionId,
+  resolveSlackChannelType: () => resolveSlackChannelType,
+  resolveSlackEventBridgeOptions: () => resolveSlackEventBridgeOptions,
+  resolveSlackMessageFormatter: () => resolveSlackMessageFormatter,
+  resolveThreadAwareSlackSessionId: () => resolveThreadAwareSlackSessionId,
+  runWithSlackTurnContext: () => runWithSlackTurnContext,
+  stripLeadingMentions: () => stripLeadingMentions
+});
+
+// src/shared/follow-up.ts
+import { formatSlackAttributedFollowUp } from "@cuylabs/channel-slack/core";
+
+// src/index.ts
+__reExport(index_exports, bolt_exports);
+__reExport(index_exports, history_exports);
+__reExport(index_exports, policy_exports);
+__reExport(index_exports, users_exports);
+__reExport(index_exports, diagnostics_exports);
+__reExport(index_exports, setup_exports);
+__reExport(index_exports, targets_exports);
+export {
+  DEFAULT_SLACK_CONTEXT_FRAGMENT_KEY,
+  SLACK_MCP_URL,
+  UnsupportedSlackInteractiveRequestError,
+  bridgeAgentEventsToSlack,
+  buildApprovalRequestMessage,
+  buildHumanInputModal,
+  buildHumanInputRequestMessage,
+  buildResolvedMessage,
+  cloneRecord,
+  createInMemorySlackInteractiveRequestStore,
+  createSlackAssistantBridge,
+  createSlackAssistantThreadContextStore,
+  createSlackChannelAdapter,
+  createSlackContextFragmentMiddleware,
+  createSlackInteractiveController,
+  createSlackMcpServerConfig,
+  createSlackSessionMap,
+  currentSlackTurnContext,
+  decodeActionValue,
+  encodeActionValue,
+  extractSlackActionToken,
+  extractSlackAttachmentsText,
+  extractSlackAuthContext,
+  extractSlackBlocksText,
+  extractSlackMessageText,
+  extractSlackUserIdentity,
+  formatSlackAttributedFollowUp,
+  isProcessableMessage,
+  markdownToSlackMrkdwn,
+  mountSlackAgent,
+  mountSlackAgentApp,
+  mountSlackAgentAppSocket,
+  mountSlackAssistantAgent,
+  mountSlackAssistantAgentSocket,
+  nowIso,
+  parseSlackMentionActivity,
+  parseSlackMessageActivity,
+  parseSlackMessageActivityFromMessageEvent,
+  resolveAssistantSessionId,
+  resolveSlackChannelType,
+  resolveSlackEventBridgeOptions,
+  resolveSlackMessageFormatter,
+  resolveThreadAwareSlackSessionId,
+  runWithSlackTurnContext,
+  stripLeadingMentions
+};

package/dist/interactive-o_NZb-Xg.d.ts

@@ -0,0 +1,47 @@
+import { AgentEvent } from '@cuylabs/agent-core';
+import { SlackActivityInfo, SlackUserIdentity } from '@cuylabs/channel-slack/core';
+
+/**
+ * Transport-neutral interactive request contracts.
+ *
+ * These types let the shared AgentEvent bridge delegate approval and
+ * human-input requests to a Slack-specific renderer without importing Bolt or
+ * Web API types into `shared/`.
+ */
+
+type SlackInteractiveRequestKind = "approval" | "human-input";
+type SlackApprovalRequest = Extract<AgentEvent, {
+    type: "approval-request";
+}>["request"];
+type SlackHumanInputRequest = Extract<AgentEvent, {
+    type: "human-input-request";
+}>["request"];
+type SlackInteractiveRequest = SlackApprovalRequest | SlackHumanInputRequest;
+interface SlackInteractiveMessageRef {
+    channel: string;
+    ts: string;
+}
+interface SlackInteractiveMessage {
+    text: string;
+    blocks?: unknown[];
+}
+interface SlackInteractiveResponder {
+    postMessage(message: SlackInteractiveMessage): Promise<SlackInteractiveMessageRef>;
+    updateMessage(ref: SlackInteractiveMessageRef, message: SlackInteractiveMessage): Promise<void>;
+}
+interface SlackInteractiveRequestBaseContext {
+    kind: SlackInteractiveRequestKind;
+    request: SlackInteractiveRequest;
+    fallbackText: string;
+}
+interface SlackInteractiveRequestContext extends SlackInteractiveRequestBaseContext {
+    slackActivity: SlackActivityInfo;
+    user: SlackUserIdentity;
+    sessionId: string;
+    message: string;
+    responder: SlackInteractiveResponder;
+}
+type SlackInteractiveRequestHandler = (context: SlackInteractiveRequestContext) => boolean | void | Promise<boolean | void>;
+type SlackEventInteractiveRequestHandler = (context: SlackInteractiveRequestBaseContext) => boolean | void | Promise<boolean | void>;
+
+export type { SlackApprovalRequest as S, SlackEventInteractiveRequestHandler as a, SlackHumanInputRequest as b, SlackInteractiveMessage as c, SlackInteractiveMessageRef as d, SlackInteractiveRequest as e, SlackInteractiveRequestBaseContext as f, SlackInteractiveRequestContext as g, SlackInteractiveRequestHandler as h, SlackInteractiveRequestKind as i, SlackInteractiveResponder as j };

package/dist/interactive.d.ts

@@ -0,0 +1,30 @@
+import { i as SlackInteractiveRequestRecord, k as SlackInteractiveRequestStore, b as SlackInteractiveApprovalRequest, S as SlackInteractiveActionIds, e as SlackInteractiveHumanInputRequest, m as SlackInteractiveResolution, d as SlackInteractiveControllerOptions, c as SlackInteractiveController } from './types-Crpil4kb.js';
+export { a as SlackInteractiveActor, f as SlackInteractiveMessageTarget, g as SlackInteractivePendingWaiter, h as SlackInteractivePostedMessage, j as SlackInteractiveRequestStatus, l as SlackInteractiveRequestWaitOptions, n as SlackInteractiveStoredRequest } from './types-Crpil4kb.js';
+import '@cuylabs/agent-core';
+import '@slack/bolt';
+import './interactive-o_NZb-Xg.js';
+import '@cuylabs/channel-slack/core';
+
+declare function createInMemorySlackInteractiveRequestStore(): SlackInteractiveRequestStore;
+declare function nowIso(): string;
+declare function cloneRecord(record: SlackInteractiveRequestRecord): SlackInteractiveRequestRecord;
+
+declare function buildApprovalRequestMessage(request: SlackInteractiveApprovalRequest, actionIds: SlackInteractiveActionIds): {
+    text: string;
+    blocks: unknown[];
+};
+declare function buildHumanInputRequestMessage(request: SlackInteractiveHumanInputRequest, actionIds: SlackInteractiveActionIds): {
+    text: string;
+    blocks: unknown[];
+};
+declare function buildResolvedMessage(label: string, resolution: SlackInteractiveResolution): {
+    text: string;
+    blocks: unknown[];
+};
+declare function buildHumanInputModal(request: SlackInteractiveHumanInputRequest, actionIds: SlackInteractiveActionIds): Record<string, unknown>;
+declare function encodeActionValue(payload: Record<string, unknown>): string;
+declare function decodeActionValue(value: unknown): Record<string, unknown>;
+
+declare function createSlackInteractiveController(options?: SlackInteractiveControllerOptions): SlackInteractiveController;
+
+export { SlackInteractiveActionIds, SlackInteractiveApprovalRequest, SlackInteractiveController, SlackInteractiveControllerOptions, SlackInteractiveHumanInputRequest, SlackInteractiveRequestRecord, SlackInteractiveRequestStore, SlackInteractiveResolution, buildApprovalRequestMessage, buildHumanInputModal, buildHumanInputRequestMessage, buildResolvedMessage, cloneRecord, createInMemorySlackInteractiveRequestStore, createSlackInteractiveController, decodeActionValue, encodeActionValue, nowIso };

package/dist/interactive.js

@@ -0,0 +1,25 @@
+import {
+  buildApprovalRequestMessage,
+  buildHumanInputModal,
+  buildHumanInputRequestMessage,
+  buildResolvedMessage,
+  cloneRecord,
+  createInMemorySlackInteractiveRequestStore,
+  createSlackInteractiveController,
+  decodeActionValue,
+  encodeActionValue,
+  nowIso
+} from "./chunk-IXY3BXU5.js";
+import "./chunk-I2KLQ2HA.js";
+export {
+  buildApprovalRequestMessage,
+  buildHumanInputModal,
+  buildHumanInputRequestMessage,
+  buildResolvedMessage,
+  cloneRecord,
+  createInMemorySlackInteractiveRequestStore,
+  createSlackInteractiveController,
+  decodeActionValue,
+  encodeActionValue,
+  nowIso
+};

package/dist/mcp.d.ts

@@ -0,0 +1,84 @@
+import { MCPServerConfig } from '@cuylabs/agent-core/mcp';
+
+/**
+ * Slack MCP integration helpers.
+ *
+ * Slack hosts an official Model Context Protocol server at
+ * `https://mcp.slack.com/mcp` that exposes Slack tools (search, read, write,
+ * canvases) authenticated with an end-user OAuth token. This module produces a
+ * `MCPServerConfig` that plugs straight into agent-core's MCP manager
+ * without forcing every caller to remember the URL or token-header convention.
+ *
+ * @example Wire per-turn from the assistant bridge
+ * ```ts
+ * import { createMCPManager } from "@cuylabs/agent-core/mcp";
+ * import {
+ *   createSlackMcpServerConfig,
+ *   mountSlackAssistantAgent,
+ * } from "@cuylabs/channel-slack-agent-core";
+ *
+ * await mountSlackAssistantAgent({
+ *   source: agent,
+ *   prepareTurn: async ({ auth }) => {
+ *     if (!auth.userToken) return {};
+ *     // Hand the user token to your agent runtime via ambient context, env,
+ *     // or a turn-scoped MCP manager you control. agent-core does not yet
+ *     // accept per-turn MCP servers on `chat()`, so the typical pattern is
+ *     // to run an MCP-aware Agent that reads `currentSlackTurnContext()`
+ *     // inside its setup.
+ *     return { context: { slackMcpServer: createSlackMcpServerConfig({ userToken: auth.userToken }) } };
+ *   },
+ * });
+ * ```
+ *
+ * @example Static agent-level wiring (single-workspace bot token mode)
+ * ```ts
+ * const manager = createMCPManager({
+ *   slack: createSlackMcpServerConfig({ userToken: process.env.SLACK_USER_TOKEN! }),
+ * });
+ * await manager.connect();
+ * ```
+ */
+
+/** Slack's hosted MCP endpoint (Streamable HTTP transport). */
+declare const SLACK_MCP_URL = "https://mcp.slack.com/mcp";
+interface CreateSlackMcpServerConfigOptions {
+    /**
+     * Slack user OAuth token (`xoxp-...`).
+     *
+     * The Slack MCP server requires a user token because most Slack tools
+     * (search, read history, write messages) act as the installing user.
+     */
+    userToken: string;
+    /**
+     * Override the MCP server URL. Defaults to `SLACK_MCP_URL`. Useful for
+     * regional endpoints or self-hosted Slack MCP deployments.
+     */
+    url?: string;
+    /**
+     * Additional headers to merge alongside `Authorization`. The bearer token
+     * is always set from `userToken` and cannot be overridden here.
+     */
+    headers?: Record<string, string>;
+    /**
+     * Connection timeout in milliseconds, forwarded to the MCP manager.
+     */
+    timeout?: number;
+    /**
+     * Whether the server is enabled. Defaults to `true`. Set to `false` to
+     * register the config without connecting (useful when the user token is
+     * conditionally available).
+     */
+    enabled?: boolean;
+    /** Human-readable server name shown by MCP status/reporting surfaces. */
+    name?: string;
+}
+/**
+ * Build an MCP server config for Slack's hosted MCP server.
+ *
+ * The returned value is consumable by `createMCPManager(...)` from
+ * `@cuylabs/agent-core/mcp`.
+ */
+declare function createSlackMcpServerConfig(options: CreateSlackMcpServerConfigOptions): MCPServerConfig;
+
+export { type CreateSlackMcpServerConfigOptions, SLACK_MCP_URL, createSlackMcpServerConfig };

package/dist/mcp.js

@@ -0,0 +1,9 @@
+import {
+  SLACK_MCP_URL,
+  createSlackMcpServerConfig
+} from "./chunk-RFHXERNL.js";
+import "./chunk-I2KLQ2HA.js";
+export {
+  SLACK_MCP_URL,
+  createSlackMcpServerConfig
+};

package/dist/options-C7OYeNR-.d.ts

@@ -0,0 +1,71 @@
+import { AgentEvent, ApprovalEvent } from '@cuylabs/agent-core';
+import { a as SlackEventInteractiveRequestHandler } from './interactive-o_NZb-Xg.js';
+
+/**
+ * Event-bridge configuration. The bridge is mode-aware (progressive,
+ * accumulate, chat-stream) and these options control formatting, status
+ * propagation, interactive-request handling, and chat-stream finalization.
+ */
+
+type HumanInputEvent = Extract<AgentEvent, {
+    type: "human-input-request";
+}>["request"];
+type ToolStartEvent = Extract<AgentEvent, {
+    type: "tool-start";
+}>;
+interface SlackEventBridgeOptions {
+    showReasoning: boolean;
+    /** Render root-agent tool rows/status updates. */
+    showToolUsage: boolean;
+    /** Render subagent child tool rows in the parent Slack task timeline. */
+    showSubagentToolUsage: boolean;
+    /** Include full subagent completion output in the subagent task row. */
+    showSubagentResultInTask: boolean;
+    formatToolTitle?: (toolName: string) => string;
+    formatToolUpdate: (toolName: string) => string;
+    formatToolDetails?: (event: ToolStartEvent) => string | undefined;
+    formatToolError: (toolName: string, error: string) => string;
+    formatReasoningUpdate: () => string;
+    formatMessageText: (text: string) => string;
+    streamingMode: "progressive" | "accumulate" | "chat-stream";
+    progressiveUpdateThreshold: number;
+    progressiveUpdateIntervalMs: number;
+    chatStreamBufferSize: number;
+    /**
+     * Maximum number of Slack task-update chunks the bridge will append to a
+     * single chat stream. Task rows are a bounded UI projection, not a durable
+     * event log.
+     */
+    maxTaskUpdates: number;
+    /**
+     * Maximum cumulative characters from task titles/details/output that the
+     * bridge will append to one chat stream.
+     */
+    maxTaskUpdateTextChars: number;
+    /**
+     * Maximum characters for a single task details/output field.
+     */
+    maxTaskUpdateFieldChars: number;
+    interactiveMode: "message-and-error" | "ignore";
+    handleInteractiveRequest?: SlackEventInteractiveRequestHandler;
+    formatApprovalRequired: (request: ApprovalEvent) => string;
+    formatHumanInputRequired: (request: HumanInputEvent) => string;
+    /**
+     * Optional hook called whenever the bridge's status label changes — used by
+     * the assistant bridge to update the assistant pane's status line via
+     * `assistant.threads.setStatus`. Errors are swallowed by the caller.
+     */
+    onStatusChange?: (label: string, event: AgentEvent | undefined) => void | Promise<void>;
+    /**
+     * Optional final-args passthrough for `chatStream.stop(...)`. When the
+     * bridge stops the chat stream on `complete`, these args (e.g. final
+     * `blocks` for a feedback widget) are merged into the `stop` call. The
+     * existing `markdown_text` final-text fallback always wins on text fields.
+     */
+    chatStreamFinalArgs?: {
+        blocks?: unknown[];
+    } & Record<string, unknown>;
+}
+declare function resolveSlackEventBridgeOptions(partial: Partial<SlackEventBridgeOptions>): SlackEventBridgeOptions;
+
+export { type SlackEventBridgeOptions as S, resolveSlackEventBridgeOptions as r };