@cuylabs/channel-slack 0.10.0 → 0.12.0

package/README.md

@@ -4,9 +4,10 @@ Agent-runtime-agnostic Slack channel primitives.
 
 This package owns reusable Slack mechanics: event parsing, message admission,
 history loading, formatting, setup inspection, auth helpers, entrypoint
-normalization, artifact publishing, interactive request rendering/storage,
-response sink contracts, and HTTP or Socket Mode transport helpers. It does not
-create or run an agent, and it does not depend on an agent SDK.
+normalization, artifact publishing, interactive request rendering/storage and
+controller wiring, response sink contracts, Slack Assistant/classic message
+mounting, and HTTP or Socket Mode transport helpers. It does not create or run
+an agent, and it does not depend on an agent SDK.
 
 Runtime-specific adapters should compose these primitives with their own turn
 types, event streams, tools, prompts, and deployment policy.
@@ -58,9 +59,41 @@ Most adapters follow the same shape:
 4. Run the application-owned runtime.
 5. Format the response for Slack.
 
+For a runtime-neutral direct Slack mount, pass a `SlackTurnSource`:
+
+```typescript
+import { mountSlackAppSocket } from "@cuylabs/channel-slack/socket";
+
+await mountSlackAppSocket({
+  source,
+  appToken: process.env.SLACK_APP_TOKEN,
+  botToken: process.env.SLACK_BOT_TOKEN,
+});
+```
+
+Add the Slack-native approval/human-input controller from the `interactive`
+subpath when your runtime can pause on interactive request events:
+
+```typescript
+import { createSlackInteractiveController } from "@cuylabs/channel-slack/interactive";
+import { mountSlackAppSocket } from "@cuylabs/channel-slack/socket";
+
+const interactive = createSlackInteractiveController({
+  namespace: "my_agent_slack",
+});
+
+await mountSlackAppSocket({
+  source,
+  interactive,
+  appToken: process.env.SLACK_APP_TOKEN,
+  botToken: process.env.SLACK_BOT_TOKEN,
+});
+```
+
 ## Documentation
 
 - [Package boundary](docs/reference/channel-slack-boundary.md)
+- [Interactive requests](docs/concepts/interactive-requests.md)
 - [Exports and peer expectations](docs/reference/exports.md)
 - [Source layout](docs/reference/source-layout.md)
 - [Docs index](docs/README.md)

package/dist/adapter/index.d.ts

@@ -0,0 +1,53 @@
+import { a as SlackChannelOptions, S as SlackChannelAdapter } from '../types-wLZzyI9r.js';
+export { b as SlackSessionStrategy, c as SlackStreamingMode, d as SlackToolStartEvent } from '../types-wLZzyI9r.js';
+import { S as SlackActivityInfo } from '../activity-ByrD9Ftr.js';
+import '../turn-BGAXddH_.js';
+import '../interactive-CbKYkkc_.js';
+import '../options-B0xQCaez.js';
+import '../types-C8nkPuD4.js';
+import '../types-Cywfj8Mj.js';
+import '../logging-Bl3HfcC8.js';
+
+/**
+ * Slack Channel Adapter
+ *
+ * Creates a configured Bolt handler that bridges a `SlackTurnSource` to Slack
+ * via @slack/bolt.
+ *
+ * The adapter mounts message/event handlers on a Bolt `App` instance and
+ * processes each turn by:
+ * 1. Parsing the Slack event into a `SlackActivityInfo`.
+ * 2. Resolving a session ID via the configured session strategy.
+ * 3. Calling `source.chat()` with the user message.
+ * 4. Streaming the response back to Slack via progressive updates or a
+ *    single final post.
+ *
+ * @example
+ * ```ts
+ * import { App } from "@slack/bolt";
+ * import { createSlackChannelAdapter } from "@cuylabs/channel-slack/adapter";
+ *
+ * const app = new App({ token: process.env.SLACK_BOT_TOKEN, signingSecret: process.env.SLACK_SIGNING_SECRET });
+ * const adapter = createSlackChannelAdapter({ source });
+ * adapter.mount(app);
+ * await app.start(3000);
+ * ```
+ */
+
+declare function createSlackChannelAdapter(options: SlackChannelOptions): SlackChannelAdapter;
+
+/**
+ * Session mapping — Slack activity info to runtime session IDs.
+ *
+ * The default strategy (`"thread-aware"`) produces natural conversation
+ * groupings by using the thread timestamp when present and falling back to
+ * the channel ID for DMs and top-level messages.
+ */
+
+interface SlackSessionMap {
+    /** Resolve (or create) a session ID for the given Slack activity. */
+    resolve(info: SlackActivityInfo): string | Promise<string>;
+}
+declare function createSlackSessionMap(options: SlackChannelOptions): SlackSessionMap;
+
+export { SlackChannelAdapter, SlackChannelOptions, type SlackSessionMap, createSlackChannelAdapter, createSlackSessionMap };

package/dist/adapter/index.js

@@ -0,0 +1,13 @@
+import {
+  createSlackChannelAdapter,
+  createSlackSessionMap
+} from "../chunk-RTDLIYEE.js";
+import "../chunk-IAQXQESO.js";
+import "../chunk-37RN2YUI.js";
+import "../chunk-3KP3CBCC.js";
+import "../chunk-FPCE5V5Y.js";
+import "../chunk-6WHFQUYQ.js";
+export {
+  createSlackChannelAdapter,
+  createSlackSessionMap
+};

package/dist/app-surface.d.ts

@@ -0,0 +1,86 @@
+import { App } from '@slack/bolt';
+import { WebClient } from '@slack/web-api';
+import { k as SlackTurnRequestContext, e as SlackAssistantUtilities, j as SlackTurnPreparation } from './turn-BGAXddH_.js';
+import { C as CreateSlackAssistantBridgeOptions, d as SlackAssistantFeedbackConfig, S as SlackAssistantBridge } from './options-DQacQDmD.js';
+import { L as Logger } from './logging-Bl3HfcC8.js';
+import { o as SlackTurnSource } from './options-B0xQCaez.js';
+import { a as SlackChannelOptions } from './types-wLZzyI9r.js';
+import { SlackFeedbackHandler } from './feedback/index.js';
+import { h as SlackInteractiveRequestHandler } from './types-Cywfj8Mj.js';
+import './activity-ByrD9Ftr.js';
+import './interactive-CbKYkkc_.js';
+import './formatting-C-kwQseI.js';
+import './types-C8nkPuD4.js';
+import '@slack/types';
+
+/**
+ * Shared installer for the direct Slack app surfaces.
+ *
+ * HTTP Events API and Socket Mode differ only in how Bolt receives inbound
+ * events. The Assistant pane, app_mention, DM/channel routing, feedback, and
+ * interactive request wiring are mounted here so both transports behave the
+ * same.
+ */
+
+interface MountSlackAppTurnRequestContext extends SlackTurnRequestContext {
+    /** Present only for Assistant-pane turns. */
+    assistant?: SlackAssistantUtilities;
+    /** Present for Assistant-pane turns; use direct history helpers for Slack API context. */
+    client?: WebClient;
+    /** Raw Bolt assistant args for advanced hosts. */
+    rawArgs?: unknown;
+}
+interface SlackAppSurfaceInteractiveController {
+    handleInteractiveRequest: SlackInteractiveRequestHandler;
+    install(app: App): void;
+}
+interface SlackAppSurfaceViewWorkflowController {
+    install(app: App): void;
+}
+interface SlackAppSurfaceOptions extends Omit<CreateSlackAssistantBridgeOptions, "feedback" | "source" | "prepareTurn" | "resolveSession" | "handleInteractiveRequest"> {
+    /** Source of Slack turns. */
+    source: SlackTurnSource;
+    /**
+     * Prepare a Slack turn for every direct Slack surface registered by this
+     * mount: Assistant pane, @mentions, and DMs.
+     */
+    prepareTurn?: (request: MountSlackAppTurnRequestContext) => SlackTurnPreparation | Promise<SlackTurnPreparation>;
+    /**
+     * Resolve the runtime session for every direct Slack surface. Returning
+     * `undefined` falls back to the configured session strategy.
+     */
+    resolveSession?: (request: MountSlackAppTurnRequestContext) => string | undefined | Promise<string | undefined>;
+    /** Register `app.event("app_mention", ...)`. @default true */
+    respondToMentions?: boolean;
+    /** Register `app.message(...)` for DMs. @default true */
+    respondToMessages?: boolean;
+    /** Forward plain channel/group messages too. @default false */
+    respondToChannelMessages?: boolean;
+    /** Resolve or skip classic Slack channel-adapter messages. Return undefined to skip. */
+    resolveMessage?: SlackChannelOptions["resolveMessage"];
+    /** Feedback config. Pass `false` to omit feedback blocks. */
+    feedback?: SlackAssistantFeedbackConfig | false;
+    /** Convenience feedback handler. Ignored when `feedback` is set. */
+    onFeedback?: SlackFeedbackHandler;
+    /** Maximum turn runtime in ms. Set `0` to disable. @default 120_000 */
+    timeoutMs?: number;
+    /** Optional logger for diagnostics. */
+    logger?: Logger;
+    /**
+     * Slack-native approval/human-input controller. Pair this with a runtime
+     * that can pause on interactive request events.
+     */
+    interactive?: SlackAppSurfaceInteractiveController;
+    /**
+     * Product/runtime Slack modal workflow controller. Use this for workflows that
+     * are richer than approval/human-input, such as incident triage forms or
+     * report-generation setup modals.
+     */
+    viewWorkflows?: SlackAppSurfaceViewWorkflowController;
+}
+interface SlackAppSurfaceResult {
+    bridge: SlackAssistantBridge;
+}
+declare function installSlackAppSurface(boltApp: App, options: SlackAppSurfaceOptions): SlackAppSurfaceResult;
+
+export { type MountSlackAppTurnRequestContext, type SlackAppSurfaceInteractiveController, type SlackAppSurfaceOptions, type SlackAppSurfaceResult, type SlackAppSurfaceViewWorkflowController, installSlackAppSurface };

package/dist/app-surface.js

@@ -0,0 +1,15 @@
+import {
+  installSlackAppSurface
+} from "./chunk-LFQCINHI.js";
+import "./chunk-Q6YX7HHK.js";
+import "./chunk-RHOIVQLD.js";
+import "./chunk-IRFKUPJN.js";
+import "./chunk-RTDLIYEE.js";
+import "./chunk-IAQXQESO.js";
+import "./chunk-37RN2YUI.js";
+import "./chunk-3KP3CBCC.js";
+import "./chunk-FPCE5V5Y.js";
+import "./chunk-6WHFQUYQ.js";
+export {
+  installSlackAppSurface
+};

package/dist/app.d.ts

@@ -0,0 +1,58 @@
+import { Server } from 'node:http';
+import { Application } from 'express';
+import { App, ExpressReceiver } from '@slack/bolt';
+import { CreateSlackBoltAppOptions } from './transports/http/index.js';
+import { e as SlackDirectAuthOptions, d as SlackDirectAuthMode } from './types-B9NfCVrk.js';
+import { SlackAppSurfaceOptions } from './app-surface.js';
+export { MountSlackAppTurnRequestContext } from './app-surface.js';
+import { S as SlackAssistantBridge } from './options-DQacQDmD.js';
+import '@slack/web-api';
+import './turn-BGAXddH_.js';
+import './activity-ByrD9Ftr.js';
+import './logging-Bl3HfcC8.js';
+import './options-B0xQCaez.js';
+import './types-C8nkPuD4.js';
+import './types-Cywfj8Mj.js';
+import './interactive-CbKYkkc_.js';
+import './types-wLZzyI9r.js';
+import './feedback/index.js';
+import '@slack/types';
+import './formatting-C-kwQseI.js';
+
+/**
+ * Unified Slack app over the HTTP Events API.
+ *
+ * This file owns only the HTTP/Bolt receiver lifecycle. The actual Slack
+ * surfaces (Assistant pane, app mentions, DMs/channel messages, feedback, and
+ * interactive requests) are mounted by `installSlackAppSurface` so Socket
+ * Mode gets the exact same behavior.
+ */
+
+interface MountSlackAppOptions extends SlackAppSurfaceOptions, Omit<CreateSlackBoltAppOptions, "app" | "path" | "botToken" | "signingSecret" | "auth"> {
+    /** Slack bot token (`xoxb-...`). @default process.env.SLACK_BOT_TOKEN */
+    botToken?: string;
+    /** Slack signing secret. @default process.env.SLACK_SIGNING_SECRET */
+    signingSecret?: string;
+    /** Direct-mode auth config (single-workspace, OAuth, custom). */
+    auth?: SlackDirectAuthOptions;
+    /** Slack Events API callback path. @default "/slack/events" */
+    path?: string;
+    /** Port to listen on. @default process.env.PORT || 3000 */
+    port?: number | null;
+    /** Optional host for `app.listen(port, host)`. */
+    host?: string;
+    /** Pre-existing Express app. */
+    app?: Application;
+}
+interface MountSlackAppResult {
+    app: Application;
+    boltApp: App;
+    receiver: ExpressReceiver;
+    authMode: SlackDirectAuthMode;
+    routePath: string;
+    bridge: SlackAssistantBridge;
+    server?: Server;
+}
+declare function mountSlackApp(options: MountSlackAppOptions): Promise<MountSlackAppResult>;
+
+export { type MountSlackAppOptions, type MountSlackAppResult, mountSlackApp };

package/dist/app.js

@@ -0,0 +1,86 @@
+import {
+  createSlackBoltApp
+} from "./chunk-QJYCHWN6.js";
+import "./chunk-S3SWPYXJ.js";
+import {
+  installSlackAppSurface
+} from "./chunk-LFQCINHI.js";
+import "./chunk-Q6YX7HHK.js";
+import "./chunk-RHOIVQLD.js";
+import "./chunk-IRFKUPJN.js";
+import "./chunk-RTDLIYEE.js";
+import "./chunk-IAQXQESO.js";
+import "./chunk-37RN2YUI.js";
+import "./chunk-3KP3CBCC.js";
+import "./chunk-FPCE5V5Y.js";
+import "./chunk-6WHFQUYQ.js";
+
+// src/app.ts
+async function mountSlackApp(options) {
+  const {
+    botToken,
+    signingSecret,
+    auth,
+    path,
+    processBeforeResponse,
+    signatureVerification,
+    boltAppOptions,
+    receiverOptions,
+    port: portOption,
+    host,
+    app: providedApp,
+    ...surfaceOptions
+  } = options;
+  const {
+    boltApp,
+    receiver,
+    app: expressApp,
+    authMode,
+    routePath
+  } = await createSlackBoltApp({
+    signingSecret,
+    path,
+    botToken,
+    auth,
+    app: providedApp,
+    processBeforeResponse,
+    signatureVerification,
+    boltAppOptions,
+    receiverOptions
+  });
+  const { bridge } = installSlackAppSurface(boltApp, surfaceOptions);
+  expressApp.use(
+    receiver.router
+  );
+  const port = portOption === void 0 ? resolvePort(process.env.PORT) : portOption;
+  let server;
+  if (!providedApp && port !== null) {
+    const onListen = () => {
+      process.stdout.write(
+        `Slack app 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;
+}
+export {
+  mountSlackApp
+};

package/dist/artifacts/index.d.ts

@@ -1,5 +1,5 @@
-import { S as SlackArtifact, l as SlackLinkArtifact, P as PublishSlackArtifactOptions, g as SlackArtifactPublication, i as SlackCanvasArtifact, j as SlackFileArtifact, k as SlackImageArtifact, m as SlackTextArtifact } from '../types-C8nkPuD4.js';
-export { a as SlackArtifactBase, b as SlackArtifactBinaryData, c as SlackArtifactCanvasResponse, d as SlackArtifactClient, e as SlackArtifactFileUploadResponse, f as SlackArtifactPostMessageResponse, h as SlackArtifactPublishMethod } from '../types-C8nkPuD4.js';
+import { S as SlackArtifact, l as SlackLinkArtifact, P as PublishSlackArtifactOptions, g as SlackArtifactPublication, i as SlackCanvasArtifact, j as SlackFileArtifact, k as SlackImageArtifact, m as SlackTextArtifact, d as SlackArtifactClient } from '../types-C8nkPuD4.js';
+export { a as SlackArtifactBase, b as SlackArtifactBinaryData, c as SlackArtifactCanvasResponse, e as SlackArtifactFileUploadResponse, f as SlackArtifactPostMessageResponse, h as SlackArtifactPublishMethod } from '../types-C8nkPuD4.js';
 
 interface SlackArtifactBlockKitMessage {
     text: string;
@@ -25,4 +25,58 @@ declare function publishSlackCanvasArtifact(options: PublishSlackArtifactOptions
     artifact: SlackCanvasArtifact;
 }): Promise<SlackArtifactPublication>;
 
-export { PublishSlackArtifactOptions, SlackArtifact, type SlackArtifactBlockKitMessage, SlackArtifactPublication, SlackCanvasArtifact, SlackFileArtifact, SlackImageArtifact, SlackLinkArtifact, SlackTextArtifact, createSlackArtifactBlocks, createSlackLinkArtifactBlocks, publishSlackArtifact, publishSlackCanvasArtifact, publishSlackFileArtifact, publishSlackImageArtifact, publishSlackLinkArtifact, publishSlackTextArtifact };
+interface SlackFinalResponseArtifactContext {
+    text: string;
+    formattedText: string;
+    client: SlackArtifactClient;
+    channelId: string;
+    threadTs?: string;
+}
+interface SlackFinalResponseArtifactResult {
+    publication: SlackArtifactPublication;
+}
+type SlackFinalResponseArtifactDeliveryMode = "supplemental" | "replace";
+type SlackFinalResponseArtifactPublisher = (context: SlackFinalResponseArtifactContext) => Promise<SlackFinalResponseArtifactResult | undefined>;
+type SlackFinalResponseArtifactValueResolver<T> = T | ((context: SlackFinalResponseArtifactContext) => T | Promise<T>);
+interface CreateSlackFinalResponseArtifactPublisherOptions {
+    /**
+     * Minimum raw-response characters required before publishing an artifact.
+     *
+     * @default 4000
+     */
+    minCharacters?: number;
+    /**
+     * Canvas/file title.
+     *
+     * @default "Agent response"
+     */
+    title?: SlackFinalResponseArtifactValueResolver<string | undefined>;
+    /**
+     * Optional Slack artifact summary.
+     */
+    summary?: SlackFinalResponseArtifactValueResolver<string | undefined>;
+    /**
+     * Prefer creating a channel canvas when the Slack client exposes
+     * `conversations.canvases.create`.
+     *
+     * @default true
+     */
+    channelCanvas?: boolean;
+    /**
+     * Fallback when Canvas publication fails.
+     *
+     * @default "file"
+     */
+    fallback?: "file" | "none";
+    /**
+     * Called after a Canvas or fallback file is published.
+     */
+    onPublished?: (result: SlackFinalResponseArtifactResult, context: SlackFinalResponseArtifactContext) => void | Promise<void>;
+    /**
+     * Called when Canvas publication fails and no fallback publication succeeds.
+     */
+    onError?: (error: unknown, context: SlackFinalResponseArtifactContext) => void | Promise<void>;
+}
+declare function createSlackFinalResponseArtifactPublisher({ minCharacters, title, summary, channelCanvas, fallback, onPublished, onError, }?: CreateSlackFinalResponseArtifactPublisherOptions): SlackFinalResponseArtifactPublisher;
+
+export { type CreateSlackFinalResponseArtifactPublisherOptions, PublishSlackArtifactOptions, SlackArtifact, type SlackArtifactBlockKitMessage, SlackArtifactClient, SlackArtifactPublication, SlackCanvasArtifact, SlackFileArtifact, type SlackFinalResponseArtifactContext, type SlackFinalResponseArtifactDeliveryMode, type SlackFinalResponseArtifactPublisher, type SlackFinalResponseArtifactResult, type SlackFinalResponseArtifactValueResolver, SlackImageArtifact, SlackLinkArtifact, SlackTextArtifact, createSlackArtifactBlocks, createSlackFinalResponseArtifactPublisher, createSlackLinkArtifactBlocks, publishSlackArtifact, publishSlackCanvasArtifact, publishSlackFileArtifact, publishSlackImageArtifact, publishSlackLinkArtifact, publishSlackTextArtifact };

package/dist/artifacts/index.js

@@ -287,8 +287,96 @@ function readUploadedFileId(response) {
 function readString(value) {
   return typeof value === "string" && value.trim() ? value.trim() : void 0;
 }
+
+// src/artifacts/final-response.ts
+var DEFAULT_MIN_CHARACTERS = 4e3;
+var DEFAULT_TITLE = "Agent response";
+function createSlackFinalResponseArtifactPublisher({
+  minCharacters = DEFAULT_MIN_CHARACTERS,
+  title = DEFAULT_TITLE,
+  summary,
+  channelCanvas = true,
+  fallback = "file",
+  onPublished,
+  onError
+} = {}) {
+  const configuredThreshold = Math.floor(minCharacters);
+  const threshold = Number.isFinite(configuredThreshold) && configuredThreshold > 0 ? configuredThreshold : DEFAULT_MIN_CHARACTERS;
+  return async (context) => {
+    const text = context.text.trim();
+    if (text.length < threshold) {
+      return void 0;
+    }
+    const resolvedTitle = normalizeText2(await resolveValue(title, context)) ?? DEFAULT_TITLE;
+    const resolvedSummary = normalizeText2(await resolveValue(summary, context));
+    let lastError;
+    try {
+      const publication = await publishSlackCanvasArtifact({
+        client: context.client,
+        channelId: context.channelId,
+        ...context.threadTs ? { threadTs: context.threadTs } : {},
+        artifact: {
+          kind: "canvas",
+          title: resolvedTitle,
+          markdown: text,
+          channelCanvas,
+          ...resolvedSummary ? { summary: resolvedSummary } : {},
+          metadata: {
+            source: "slack-final-response",
+            characterCount: text.length
+          }
+        }
+      });
+      const result = { publication };
+      await onPublished?.(result, context);
+      return result;
+    } catch (error) {
+      lastError = error;
+    }
+    if (fallback === "file") {
+      try {
+        const publication = await publishSlackTextArtifact({
+          client: context.client,
+          channelId: context.channelId,
+          ...context.threadTs ? { threadTs: context.threadTs } : {},
+          artifact: {
+            kind: "text",
+            title: resolvedTitle,
+            text,
+            filename: filenameFromTitle2(resolvedTitle),
+            ...resolvedSummary ? { summary: resolvedSummary } : {},
+            metadata: {
+              source: "slack-final-response",
+              characterCount: text.length,
+              canvasFallback: true
+            }
+          }
+        });
+        const result = { publication };
+        await onPublished?.(result, context);
+        return result;
+      } catch (error) {
+        lastError = error;
+      }
+    }
+    await onError?.(lastError, context);
+    return void 0;
+  };
+}
+async function resolveValue(value, context) {
+  return typeof value === "function" ? await value(context) : value;
+}
+function normalizeText2(value) {
+  const trimmed = value?.trim();
+  return trimmed ? trimmed : void 0;
+}
+function filenameFromTitle2(title) {
+  const slug = title.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  return `${slug || "agent-response"}.txt`;
+}
 export {
   createSlackArtifactBlocks,
+  createSlackFinalResponseArtifactPublisher,
   createSlackLinkArtifactBlocks,
   publishSlackArtifact,
   publishSlackCanvasArtifact,

package/dist/assistant/index.d.ts

@@ -1,58 +1,23 @@
-import { S as SlackActivityInfo } from '../activity-ByrD9Ftr.js';
+import { C as CreateSlackAssistantBridgeOptions, S as SlackAssistantBridge } from '../options-DQacQDmD.js';
+export { A as AssistantLifecycleArgs, a as AssistantThreadStartedArgs, M as MaybePromise, P as ParsedAssistantUserMessage, b as SlackAssistantCancelControlOptions, c as SlackAssistantCancelControlVisibleWhen, d as SlackAssistantFeedbackConfig, e as SlackAssistantSessionStrategy, f as SlackAssistantStatusContext, g as SlackAssistantThreadContextStoreLike, h as SlackAssistantThreadStartedContext, i as SlackAssistantTurnCancelContext, j as SlackAssistantTurnControlsOptions, k as SlackAssistantTurnPreparation, l as SlackAssistantUserMessageContext, m as createSlackAssistantThreadContextStore, p as parseSlackMessageActivityFromMessageEvent, r as resolveAssistantSessionId } from '../options-DQacQDmD.js';
+import '@slack/bolt';
+import '@slack/web-api';
+import '../turn-BGAXddH_.js';
+import '../activity-ByrD9Ftr.js';
+import '../interactive-CbKYkkc_.js';
+import '../formatting-C-kwQseI.js';
+import '../options-B0xQCaez.js';
+import '../types-C8nkPuD4.js';
+import '../types-Cywfj8Mj.js';
+import '../feedback/index.js';
+import '@slack/types';
+import '../logging-Bl3HfcC8.js';
 
 /**
- * Per-thread Assistant context store.
- *
- * Bolt's default store persists context in message metadata, but also keeps a
- * single process-local cached context. That cache is not keyed by thread, so a
- * multi-user app can read the wrong channel-of-origin context after another
- * assistant thread changes it. This store keeps the same metadata persistence
- * model while caching by Slack channel/thread.
+ * `createSlackAssistantBridge` factory — assembles the three lifecycle
+ * middlewares into a Bolt `Assistant` and wires the feedback action handler.
  */
-type ThreadStoreArgs = {
-    context?: {
-        botUserId?: string;
-    };
-    client?: {
-        conversations?: {
-            replies?: (args: Record<string, unknown>) => Promise<{
-                messages?: unknown[];
-            }>;
-        };
-        chat?: {
-            update?: (args: Record<string, unknown>) => Promise<unknown>;
-        };
-    };
-    logger?: {
-        debug?: (...args: unknown[]) => void;
-    };
-    payload?: unknown;
-};
-interface SlackAssistantThreadContextStoreLike {
-    get: (args: ThreadStoreArgs) => Promise<unknown>;
-    save: (args: ThreadStoreArgs) => Promise<void>;
-}
-declare function createSlackAssistantThreadContextStore(): SlackAssistantThreadContextStoreLike;
 
-/**
- * Parse the `message` payload delivered to a Bolt assistant `userMessage`
- * handler into the same shape as `parseSlackMessageActivity`.
- *
- * Bolt routes a fairly wide message event to assistant handlers, so we keep
- * the input typed loosely and inspect only the fields we need.
- */
-
-interface ParsedAssistantUserMessage extends SlackActivityInfo {
-    /** Slack `channel` identifier, always present after parsing. */
-    channel: string;
-    /** Slack `thread_ts` identifier — the assistant API requires a thread. */
-    threadTs: string;
-}
-/**
- * Returns `undefined` when the event is not a parseable user message — bolt
- * delivers join/leave/edit/delete subtypes through the same handler, and the
- * caller should ignore them.
- */
-declare function parseSlackMessageActivityFromMessageEvent(message: unknown): ParsedAssistantUserMessage | undefined;
+declare function createSlackAssistantBridge(options: CreateSlackAssistantBridgeOptions): SlackAssistantBridge;
 
-export { type ParsedAssistantUserMessage, type SlackAssistantThreadContextStoreLike, createSlackAssistantThreadContextStore, parseSlackMessageActivityFromMessageEvent };
+export { CreateSlackAssistantBridgeOptions, SlackAssistantBridge, createSlackAssistantBridge };