@cuylabs/channel-slack 0.10.0 → 0.11.0

package/dist/runtime/index.d.ts

@@ -1,225 +1,11 @@
-import { d as SlackArtifactClient, g as SlackArtifactPublication } from '../types-C8nkPuD4.js';
-import { c as SlackInteractiveApprovalRequest, e as SlackInteractiveHumanInputRequest } from '../types-Cywfj8Mj.js';
-import { a as SlackEventInteractiveRequestHandler } from '../interactive-CbKYkkc_.js';
+import { i as SlackTurnEvent, S as SlackEventBridgeOptions } from '../options-B0xQCaez.js';
+export { a as SlackFinalResponseArtifactContext, b as SlackFinalResponseArtifactDeliveryMode, c as SlackFinalResponseArtifactPublisher, d as SlackFinalResponseArtifactResult, e as SlackTurnApprovalRequestEvent, f as SlackTurnApprovalResolvedEvent, g as SlackTurnCompleteEvent, h as SlackTurnErrorEvent, j as SlackTurnEventBase, k as SlackTurnHumanInputRequestEvent, l as SlackTurnHumanInputResolvedEvent, m as SlackTurnReasoningEndEvent, n as SlackTurnReasoningStartEvent, o as SlackTurnSource, p as SlackTurnSourceChatOptions, q as SlackTurnStatus, r as SlackTurnStatusEvent, s as SlackTurnSubagentCompleteEvent, t as SlackTurnSubagentErrorEvent, u as SlackTurnSubagentEventBase, v as SlackTurnSubagentEventEvent, w as SlackTurnSubagentStartEvent, x as SlackTurnTextDeltaEvent, y as SlackTurnTextEndEvent, z as SlackTurnTextStartEvent, A as SlackTurnToolErrorEvent, B as SlackTurnToolResultEvent, C as SlackTurnToolStartEvent, D as resolveSlackEventBridgeOptions } from '../options-B0xQCaez.js';
 import { SlackResponseSink } from '../responses/index.js';
+import '../types-C8nkPuD4.js';
+import '../types-Cywfj8Mj.js';
+import '../interactive-CbKYkkc_.js';
 import '../activity-ByrD9Ftr.js';
 
-interface SlackTurnSourceChatOptions {
-    abort?: AbortSignal;
-    system?: string;
-}
-interface SlackTurnSource {
-    chat(sessionId: string, message: string, options?: SlackTurnSourceChatOptions): AsyncGenerator<SlackTurnEvent>;
-}
-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 SlackTurnStatus = "thinking" | "reasoning" | "calling-tool" | "waiting-approval" | "waiting-input" | "processing" | "error" | string;
-interface SlackTurnEventBase {
-    type: string;
-    [key: string]: unknown;
-}
-interface SlackTurnTextStartEvent extends SlackTurnEventBase {
-    type: "text-start";
-}
-interface SlackTurnTextDeltaEvent extends SlackTurnEventBase {
-    type: "text-delta";
-    text: string;
-}
-interface SlackTurnTextEndEvent extends SlackTurnEventBase {
-    type: "text-end";
-}
-interface SlackTurnReasoningStartEvent extends SlackTurnEventBase {
-    type: "reasoning-start";
-}
-interface SlackTurnReasoningEndEvent extends SlackTurnEventBase {
-    type: "reasoning-end";
-}
-interface SlackTurnToolStartEvent extends SlackTurnEventBase {
-    type: "tool-start";
-    toolCallId: string;
-    toolName: string;
-    input?: unknown;
-}
-interface SlackTurnToolResultEvent extends SlackTurnEventBase {
-    type: "tool-result";
-    toolCallId: string;
-    toolName: string;
-    result?: unknown;
-}
-interface SlackTurnToolErrorEvent extends SlackTurnEventBase {
-    type: "tool-error";
-    toolCallId: string;
-    toolName: string;
-    error: string;
-}
-interface SlackTurnSubagentEventBase extends SlackTurnEventBase {
-    dispatchId: string;
-    role: string;
-    title?: string;
-    parentDispatchId?: string;
-    agentPath?: string;
-    depth?: number;
-}
-interface SlackTurnSubagentStartEvent extends SlackTurnSubagentEventBase {
-    type: "subagent-start";
-}
-interface SlackTurnSubagentEventEvent extends SlackTurnSubagentEventBase {
-    type: "subagent-event";
-    event: SlackTurnEvent;
-}
-interface SlackTurnSubagentCompleteEvent extends SlackTurnSubagentEventBase {
-    type: "subagent-complete";
-    output?: unknown;
-}
-interface SlackTurnSubagentErrorEvent extends SlackTurnSubagentEventBase {
-    type: "subagent-error";
-    error: string;
-}
-interface SlackTurnStatusEvent extends SlackTurnEventBase {
-    type: "status";
-    status: SlackTurnStatus;
-}
-interface SlackTurnCompleteEvent extends SlackTurnEventBase {
-    type: "complete";
-    output?: string;
-}
-interface SlackTurnErrorEvent extends SlackTurnEventBase {
-    type: "error";
-    error: unknown;
-}
-interface SlackTurnApprovalRequestEvent extends SlackTurnEventBase {
-    type: "approval-request";
-    request: SlackInteractiveApprovalRequest;
-}
-interface SlackTurnApprovalResolvedEvent extends SlackTurnEventBase {
-    type: "approval-resolved";
-}
-interface SlackTurnHumanInputRequestEvent extends SlackTurnEventBase {
-    type: "human-input-request";
-    request: SlackInteractiveHumanInputRequest;
-}
-interface SlackTurnHumanInputResolvedEvent extends SlackTurnEventBase {
-    type: "human-input-resolved";
-}
-type SlackTurnEvent = SlackTurnTextStartEvent | SlackTurnTextDeltaEvent | SlackTurnTextEndEvent | SlackTurnReasoningStartEvent | SlackTurnReasoningEndEvent | SlackTurnToolStartEvent | SlackTurnToolResultEvent | SlackTurnToolErrorEvent | SlackTurnSubagentStartEvent | SlackTurnSubagentEventEvent | SlackTurnSubagentCompleteEvent | SlackTurnSubagentErrorEvent | SlackTurnStatusEvent | SlackTurnCompleteEvent | SlackTurnErrorEvent | SlackTurnApprovalRequestEvent | SlackTurnApprovalResolvedEvent | SlackTurnHumanInputRequestEvent | SlackTurnHumanInputResolvedEvent;
-
-/**
- * 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 ApprovalRequest = SlackTurnApprovalRequestEvent["request"];
-type HumanInputRequest = SlackTurnHumanInputRequestEvent["request"];
-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: SlackTurnToolStartEvent) => string | undefined;
-    /**
-     * Format the completed tool output shown in Slack task rows.
-     *
-     * Return `undefined` to use the default generic formatter. Return `null` to
-     * intentionally omit task-row output for this tool result.
-     */
-    formatToolResultOutput?: (event: SlackTurnToolResultEvent) => string | null | 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: ApprovalRequest) => string;
-    formatHumanInputRequired: (request: HumanInputRequest) => 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: SlackTurnEvent | 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>;
-    /**
-     * Optional post-processing hook for publishing a rich artifact from the final
-     * accumulated response, such as a Slack Canvas for long answers.
-     */
-    publishFinalResponseArtifact?: SlackFinalResponseArtifactPublisher;
-    /**
-     * Controls whether artifact publication is additive or becomes the primary
-     * final-answer surface.
-     *
-     * - `supplemental`: finalize the Slack text normally, then publish artifact.
-     * - `replace`: publish artifact first and use a compact Slack final message.
-     *
-     * @default "supplemental"
-     */
-    finalResponseArtifactMode?: SlackFinalResponseArtifactDeliveryMode;
-    /**
-     * When replacement mode is active, continue streaming text up to this many
-     * raw characters, then suppress further text deltas and publish the full
-     * answer as an artifact at completion. This preserves normal short-answer
-     * streaming without flooding Slack for long answers.
-     *
-     * @default 4000
-     */
-    finalResponseArtifactStreamThreshold?: number;
-    /**
-     * Notice appended when replacement mode suppresses the remaining text stream.
-     */
-    formatFinalResponseArtifactContinuationNotice?: (context: Pick<SlackFinalResponseArtifactContext, "text" | "formattedText">) => string;
-    /**
-     * Final compact message used when an artifact replaces the full Slack text.
-     */
-    formatFinalResponseArtifactMessage?: (result: SlackFinalResponseArtifactResult, context: SlackFinalResponseArtifactContext) => string;
-    /**
-     * Called when `publishFinalResponseArtifact` throws. Errors from this hook
-     * are swallowed so artifact publication cannot break a completed turn.
-     */
-    onFinalResponseArtifactError?: (error: unknown, context: SlackFinalResponseArtifactContext) => void | Promise<void>;
-}
-declare function resolveSlackEventBridgeOptions(partial: Partial<SlackEventBridgeOptions>): SlackEventBridgeOptions;
-
 /**
  * Event bridge — maps a runtime-neutral `SlackTurnEvent` stream to a Slack
  * conversation via a `SlackResponseSink`.
@@ -257,4 +43,4 @@ declare class UnsupportedSlackInteractiveRequestError extends Error {
     constructor(kind: "approval" | "human-input", requestId: string, message: string);
 }
 
-export { type SlackEventBridgeOptions, type SlackFinalResponseArtifactContext, type SlackFinalResponseArtifactDeliveryMode, type SlackFinalResponseArtifactPublisher, type SlackFinalResponseArtifactResult, type SlackTurnApprovalRequestEvent, type SlackTurnApprovalResolvedEvent, type SlackTurnCompleteEvent, type SlackTurnErrorEvent, type SlackTurnEvent, type SlackTurnEventBase, type SlackTurnHumanInputRequestEvent, type SlackTurnHumanInputResolvedEvent, type SlackTurnReasoningEndEvent, type SlackTurnReasoningStartEvent, type SlackTurnSource, type SlackTurnSourceChatOptions, type SlackTurnStatus, type SlackTurnStatusEvent, type SlackTurnSubagentCompleteEvent, type SlackTurnSubagentErrorEvent, type SlackTurnSubagentEventBase, type SlackTurnSubagentEventEvent, type SlackTurnSubagentStartEvent, type SlackTurnTextDeltaEvent, type SlackTurnTextEndEvent, type SlackTurnTextStartEvent, type SlackTurnToolErrorEvent, type SlackTurnToolResultEvent, type SlackTurnToolStartEvent, UnsupportedSlackInteractiveRequestError, bridgeSlackTurnEventsToSlack, resolveSlackEventBridgeOptions };
+export { SlackEventBridgeOptions, SlackTurnEvent, UnsupportedSlackInteractiveRequestError, bridgeSlackTurnEventsToSlack };

package/dist/socket.d.ts

@@ -0,0 +1,142 @@
+import { App } from '@slack/bolt';
+import { C as CreateSlackSocketBoltAppOptions } from './bolt-app-BM0tiL7c.js';
+import { e as SlackDirectAuthOptions, d as SlackDirectAuthMode } from './types-B9NfCVrk.js';
+import { S as SlackAssistantBridge, C as CreateSlackAssistantBridgeOptions, d as SlackAssistantFeedbackConfig } from './options-DQacQDmD.js';
+import { SlackAppSurfaceOptions } from './app-surface.js';
+import { SlackFeedbackHandler } from './feedback/index.js';
+import 'node:http';
+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 './logging-Bl3HfcC8.js';
+import './types-wLZzyI9r.js';
+import '@slack/types';
+
+/**
+ * Socket Mode helpers for direct Slack.
+ *
+ * Slack's Socket Mode is the recommended local-development transport because
+ * it does not need a public webhook URL. The starter agent in
+ * `bolt-js-starter-agent` uses it for that reason. These helpers mirror the
+ * HTTP/Express mounts for the Socket Mode case so application code stays
+ * identical across transports.
+ *
+ * @example
+ * ```ts
+ * import { mountSlackAssistantSocket } from "@cuylabs/channel-slack/socket";
+ *
+ * await mountSlackAssistantSocket({
+ *   source: agent,
+ *   appToken: process.env.SLACK_APP_TOKEN, // xapp-...
+ *   botToken: process.env.SLACK_BOT_TOKEN, // xoxb-...
+ *   getSuggestedPrompts: () => ({
+ *     prompts: [
+ *       { title: "Roll dice", message: "Roll 2d20" },
+ *       { title: "Brainstorm", message: "Help me brainstorm a launch plan" },
+ *     ],
+ *   }),
+ * });
+ * ```
+ */
+
+interface MountSlackAssistantSocketOptions extends Omit<CreateSlackAssistantBridgeOptions, "feedback"> {
+    /**
+     * Slack app-level token (`xapp-...`) with `connections:write` scope.
+     * @default process.env.SLACK_APP_TOKEN
+     */
+    appToken?: string;
+    /**
+     * Slack bot token (`xoxb-...`) for the bot user in single-workspace mode.
+     * @default process.env.SLACK_BOT_TOKEN
+     */
+    botToken?: string;
+    /**
+     * Direct-mode auth config (single-workspace, OAuth, custom).
+     *
+     * Socket Mode still requires `appToken`; OAuth/custom authorize only change
+     * how Bolt resolves workspace bot/user tokens once events arrive.
+     */
+    auth?: SlackDirectAuthOptions;
+    /**
+     * Additional Bolt `App` options. Socket/auth fields are controlled by this
+     * helper and cannot be overridden. In OAuth Socket Mode, use `port` here to
+     * control the small HTTP server Bolt starts for install/callback routes.
+     */
+    boltAppOptions?: CreateSlackSocketBoltAppOptions["boltAppOptions"];
+    /**
+     * Additional native Socket Mode receiver options. Use this for websocket
+     * health tuning such as ping timeouts and reconnect behavior.
+     */
+    socketModeReceiverOptions?: CreateSlackSocketBoltAppOptions["socketModeReceiverOptions"];
+    /**
+     * Feedback config. Pass `false` to omit the feedback block. Pass an object
+     * to override action ids, button labels, or the handler.
+     */
+    feedback?: SlackAssistantFeedbackConfig | false;
+    /**
+     * Convenience shorthand: `onFeedback: handler` is equivalent to
+     * `feedback: { onFeedback: handler }`. Ignored if `feedback` is set.
+     */
+    onFeedback?: SlackFeedbackHandler;
+    /**
+     * Whether to call `app.start()` automatically. When `false`, callers own
+     * the lifecycle and must call `result.boltApp.start()` themselves.
+     * @default true
+     */
+    start?: boolean;
+}
+interface MountSlackAssistantSocketResult {
+    boltApp: App;
+    bridge: SlackAssistantBridge;
+    authMode: SlackDirectAuthMode;
+}
+interface MountSlackAppSocketOptions extends SlackAppSurfaceOptions {
+    /**
+     * Slack app-level token (`xapp-...`) with `connections:write` scope.
+     * @default process.env.SLACK_APP_TOKEN
+     */
+    appToken?: string;
+    /**
+     * Slack bot token (`xoxb-...`) for the bot user in single-workspace mode.
+     * @default process.env.SLACK_BOT_TOKEN
+     */
+    botToken?: string;
+    /**
+     * Direct-mode auth config (single-workspace, OAuth, custom).
+     *
+     * Socket Mode still requires `appToken`; OAuth/custom authorize only change
+     * how Bolt resolves workspace bot/user tokens once events arrive.
+     */
+    auth?: SlackDirectAuthOptions;
+    /**
+     * Additional Bolt `App` options. Socket/auth fields are controlled by this
+     * helper and cannot be overridden. In OAuth Socket Mode, use `port` here to
+     * control the small HTTP server Bolt starts for install/callback routes.
+     */
+    boltAppOptions?: CreateSlackSocketBoltAppOptions["boltAppOptions"];
+    /**
+     * Additional native Socket Mode receiver options. Use this for websocket
+     * health tuning such as ping timeouts and reconnect behavior.
+     */
+    socketModeReceiverOptions?: CreateSlackSocketBoltAppOptions["socketModeReceiverOptions"];
+    /**
+     * Whether to call `app.start()` automatically. When `false`, callers own
+     * the lifecycle and must call `result.boltApp.start()` themselves.
+     * @default true
+     */
+    start?: boolean;
+}
+interface MountSlackAppSocketResult {
+    boltApp: App;
+    bridge: SlackAssistantBridge;
+    authMode: SlackDirectAuthMode;
+}
+declare function mountSlackAssistantSocket(options: MountSlackAssistantSocketOptions): Promise<MountSlackAssistantSocketResult>;
+declare function mountSlackAppSocket(options: MountSlackAppSocketOptions): Promise<MountSlackAppSocketResult>;
+
+export { type MountSlackAppSocketOptions, type MountSlackAppSocketResult, type MountSlackAssistantSocketOptions, type MountSlackAssistantSocketResult, mountSlackAppSocket, mountSlackAssistantSocket };

package/dist/socket.js

@@ -0,0 +1,77 @@
+import {
+  createSlackSocketBoltApp
+} from "./chunk-73QXT7MA.js";
+import "./chunk-S3SWPYXJ.js";
+import {
+  installSlackAppSurface
+} from "./chunk-LFQCINHI.js";
+import {
+  createSlackAssistantBridge
+} from "./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/socket.ts
+async function mountSlackAssistantSocket(options) {
+  const {
+    appToken: appTokenOption,
+    botToken: botTokenOption,
+    auth,
+    boltAppOptions,
+    socketModeReceiverOptions,
+    feedback: feedbackOption,
+    onFeedback,
+    start,
+    ...bridgeOptions
+  } = options;
+  const { boltApp, authMode } = await createSlackSocketBoltApp({
+    appToken: appTokenOption,
+    botToken: botTokenOption,
+    auth,
+    boltAppOptions,
+    socketModeReceiverOptions
+  });
+  const feedback = feedbackOption !== void 0 ? feedbackOption : onFeedback ? { onFeedback } : void 0;
+  const bridge = createSlackAssistantBridge({
+    ...bridgeOptions,
+    ...feedback !== void 0 ? { feedback } : {}
+  });
+  bridge.install(boltApp);
+  if (start !== false) {
+    await boltApp.start();
+  }
+  return { boltApp, bridge, authMode };
+}
+async function mountSlackAppSocket(options) {
+  const {
+    appToken: appTokenOption,
+    botToken: botTokenOption,
+    auth,
+    boltAppOptions,
+    socketModeReceiverOptions,
+    start,
+    ...surfaceOptions
+  } = options;
+  const { boltApp, authMode } = await createSlackSocketBoltApp({
+    appToken: appTokenOption,
+    botToken: botTokenOption,
+    auth,
+    boltAppOptions,
+    socketModeReceiverOptions
+  });
+  const { bridge } = installSlackAppSurface(boltApp, surfaceOptions);
+  if (start !== false) {
+    await boltApp.start();
+  }
+  return { boltApp, bridge, authMode };
+}
+export {
+  mountSlackAppSocket,
+  mountSlackAssistantSocket
+};

package/dist/transports/index.d.ts

@@ -1,5 +1,6 @@
 export { CreateSlackBoltAppOptions, CreateSlackBoltAppResult, createSlackBoltApp, createSlackBoltApp as createSlackHttpBoltApp } from './http/index.js';
-export { CreateSlackSocketBoltAppOptions, CreateSlackSocketBoltAppResult, SlackSocketModePostgresLock, SlackSocketModePostgresLockClient, SlackSocketModePostgresLockOptions, SlackSocketModePostgresLockPool, SlackSocketModeProcessLock, SlackSocketModeProcessLockOptions, acquireSlackSocketModePostgresLock, acquireSlackSocketModeProcessLock, createSlackSocketBoltApp } from './socket/index.js';
+export { C as CreateSlackSocketBoltAppOptions, a as CreateSlackSocketBoltAppResult, c as createSlackSocketBoltApp } from '../bolt-app-BM0tiL7c.js';
+export { SlackSocketModePostgresLock, SlackSocketModePostgresLockClient, SlackSocketModePostgresLockOptions, SlackSocketModePostgresLockPool, SlackSocketModeProcessLock, SlackSocketModeProcessLockOptions, acquireSlackSocketModePostgresLock, acquireSlackSocketModeProcessLock } from './socket/index.js';
 export { S as SlackSocketModeReceiverRuntimeOptions, a as SlackSocketModeRestartGuard, b as SlackSocketModeRuntime, c as SlackSocketModeRuntimeOptions, d as SlackSocketModeRuntimePolicy, e as createSlackSdkLogger, f as createSlackSocketModeRestartGuard, g as createSlackSocketModeRuntime, r as redactSlackSocketModeLogValue } from '../runtime-BNBHOZSQ.js';
 export { LogLevel as SlackSdkLogLevel, Logger as SlackSdkLogger } from '@slack/bolt';
 import 'express';

package/dist/transports/socket/index.d.ts

@@ -1,55 +1,10 @@
-import { AppOptions, SocketModeReceiverOptions, App } from '@slack/bolt';
-export { LogLevel as SlackSdkLogLevel, Logger as SlackSdkLogger } from '@slack/bolt';
-import { e as SlackDirectAuthOptions, d as SlackDirectAuthMode } from '../../types-B9NfCVrk.js';
+export { C as CreateSlackSocketBoltAppOptions, a as CreateSlackSocketBoltAppResult, c as createSlackSocketBoltApp } from '../../bolt-app-BM0tiL7c.js';
 import { L as Logger } from '../../logging-Bl3HfcC8.js';
 export { S as SlackSocketModeReceiverRuntimeOptions, a as SlackSocketModeRestartGuard, b as SlackSocketModeRuntime, c as SlackSocketModeRuntimeOptions, d as SlackSocketModeRuntimePolicy, e as createSlackSdkLogger, f as createSlackSocketModeRestartGuard, g as createSlackSocketModeRuntime, r as redactSlackSocketModeLogValue } from '../../runtime-BNBHOZSQ.js';
+export { LogLevel as SlackSdkLogLevel, Logger as SlackSdkLogger } from '@slack/bolt';
+import '../../types-B9NfCVrk.js';
 import 'node:http';
 
-/**
- * `createSlackSocketBoltApp` — builds a Socket Mode Bolt `App` from the
- * package's structured auth options. Mirrors `createSlackBoltApp` without
- * owning any assistant/app surface mounting.
- */
-
-type ControlledSocketBoltAppOption = "receiver" | "socketMode" | "appToken" | "token" | "authorize" | "botId" | "botUserId" | "clientId" | "clientSecret" | "stateSecret" | "redirectUri" | "installationStore" | "scopes" | "installerOptions";
-type ControlledSocketModeReceiverOption = "appToken" | "clientId" | "clientSecret" | "stateSecret" | "redirectUri" | "installationStore" | "scopes" | "installerOptions" | "logger" | "logLevel";
-interface CreateSlackSocketBoltAppOptions {
-    /**
-     * Slack app-level token (`xapp-...`) with `connections:write` scope.
-     * @default process.env.SLACK_APP_TOKEN
-     */
-    appToken?: string;
-    /**
-     * Convenience override for single-workspace mode.
-     * @default process.env.SLACK_BOT_TOKEN
-     */
-    botToken?: string;
-    /**
-     * Direct-mode auth configuration.
-     *
-     * - omit for single-workspace token mode
-     * - use `{ mode: "oauth", ... }` for Bolt-managed installs
-     * - use `{ mode: "authorize", authorize }` for external token resolution
-     */
-    auth?: SlackDirectAuthOptions;
-    /**
-     * Additional Bolt `App` options passed after this package sets Socket Mode
-     * and auth. Use for logger/clientOptions and non-auth native Bolt config.
-     */
-    boltAppOptions?: Partial<Omit<AppOptions, ControlledSocketBoltAppOption>>;
-    /**
-     * Additional native Socket Mode receiver options. Use this for websocket
-     * health tuning such as ping timeouts, reconnect behavior, and receiver
-     * error handling. Auth/OAuth fields stay controlled by this helper.
-     */
-    socketModeReceiverOptions?: Partial<Omit<SocketModeReceiverOptions, ControlledSocketModeReceiverOption>>;
-}
-interface CreateSlackSocketBoltAppResult {
-    boltApp: App;
-    authMode: SlackDirectAuthMode;
-}
-declare function createSlackSocketBoltApp(options?: CreateSlackSocketBoltAppOptions): Promise<CreateSlackSocketBoltAppResult>;
-
 interface SlackSocketModeProcessLockOptions {
     appSlug: string;
     appToken?: string;
@@ -91,4 +46,4 @@ interface SlackSocketModePostgresLock {
 }
 declare function acquireSlackSocketModePostgresLock({ appSlug, appToken, client, connectionString, enabled, logger, namespace, pool, }: SlackSocketModePostgresLockOptions): Promise<SlackSocketModePostgresLock | undefined>;
 
-export { type CreateSlackSocketBoltAppOptions, type CreateSlackSocketBoltAppResult, type SlackSocketModePostgresLock, type SlackSocketModePostgresLockClient, type SlackSocketModePostgresLockOptions, type SlackSocketModePostgresLockPool, type SlackSocketModeProcessLock, type SlackSocketModeProcessLockOptions, acquireSlackSocketModePostgresLock, acquireSlackSocketModeProcessLock, createSlackSocketBoltApp };
+export { type SlackSocketModePostgresLock, type SlackSocketModePostgresLockClient, type SlackSocketModePostgresLockOptions, type SlackSocketModePostgresLockPool, type SlackSocketModeProcessLock, type SlackSocketModeProcessLockOptions, acquireSlackSocketModePostgresLock, acquireSlackSocketModeProcessLock };