@cuylabs/channel-slack-agent-core 0.1.0

package/dist/options-Uf-qmQKN.d.ts

@@ -0,0 +1,263 @@
+import { AgentTurnSource, AgentEvent, Logger } from '@cuylabs/agent-core';
+import { AssistantUserMessageMiddleware, AssistantThreadStartedMiddleware, Assistant, App } from '@slack/bolt';
+import { WebClient } from '@slack/web-api';
+import { SlackAuthContext, SlackAssistantThreadContext, SlackAssistantUtilities, SlackTurnPreparation, SlackAssistantTaskDisplayMode, SlackAssistantStatusUpdate, SlackAssistantSuggestedPrompts, SlackChatStreamStartArgs, SlackMessageFormattingOptions } from '@cuylabs/channel-slack/core';
+import { h as SlackInteractiveRequestHandler } from './interactive-o_NZb-Xg.js';
+import { S as SlackEventBridgeOptions } from './options-C7OYeNR-.js';
+import { SlackFeedbackBlockOptions, SlackFeedbackHandler } from '@cuylabs/channel-slack/feedback';
+import { ParsedAssistantUserMessage } from '@cuylabs/channel-slack/assistant';
+
+/**
+ * Session strategies for the Bolt Assistant bridge.
+ *
+ * Slack assistant conversations are always threaded, including Assistant DMs,
+ * so the default assistant mapping keys sessions by `channel:thread_ts`. This
+ * intentionally differs from the shared channel adapter, where plain DMs use
+ * only the DM channel id.
+ */
+
+type SlackAssistantSessionStrategy = "thread-aware" | "channel-id" | "user-per-thread";
+declare function resolveAssistantSessionId(message: ParsedAssistantUserMessage, strategy: SlackAssistantSessionStrategy): string;
+
+/**
+ * Public option types for the Slack Assistant bridge.
+ *
+ * Kept in a dedicated file so the lifecycle handlers, sink, and helpers can
+ * reference them without dragging the entire factory in.
+ */
+
+type MaybePromise<T> = T | Promise<T>;
+/**
+ * Structural alias for Bolt's `AssistantThreadContextStore`. Bolt does not
+ * re-export the type at the package root, so we redefine its `get` / `save`
+ * surface here. `DefaultThreadContextStore` from `@slack/bolt` (the bridge's
+ * default when no override is provided) implements the same shape.
+ */
+interface SlackAssistantThreadContextStoreLike {
+    get: (args: any) => Promise<unknown>;
+    save: (args: any) => Promise<void>;
+}
+/**
+ * Loose alias for the runtime shape of arguments handed to assistant
+ * lifecycle middleware. Bolt does not re-export `AllAssistantMiddlewareArgs`
+ * either, but every handler we register receives a compatible record.
+ */
+type AssistantLifecycleArgs = Parameters<AssistantUserMessageMiddleware>[0];
+/** Args specifically for the `threadStarted` middleware. */
+type AssistantThreadStartedArgs = Parameters<AssistantThreadStartedMiddleware>[0];
+/**
+ * Context handed to `getSuggestedPrompts` / `getInitialReply` /
+ * `formatThreadTitle` when a Slack assistant thread starts.
+ */
+interface SlackAssistantThreadStartedContext {
+    /** The raw `assistant_thread_started` event payload. */
+    event: AssistantThreadStartedArgs["payload"];
+    context: AssistantThreadStartedArgs["context"];
+    client: AssistantThreadStartedArgs["client"];
+    logger: AssistantThreadStartedArgs["logger"];
+}
+/**
+ * Context for per-message agent-side preparation. Returned values augment the
+ * agent turn but never replace the bridge's lifecycle calls (status, stream,
+ * feedback, etc.).
+ *
+ * `auth`, `threadContext`, and `assistant` are populated by the bridge before
+ * `prepareTurn` / `resolveSession` run, so callers can read tokens and the
+ * channel-of-origin metadata (or call `setStatus` etc. mid-prep) without
+ * reaching into `rawArgs`.
+ */
+interface SlackAssistantUserMessageContext {
+    message: ParsedAssistantUserMessage;
+    sessionId: string;
+    /** Slack Web API client for direct Slack calls scoped to this turn. */
+    client: WebClient;
+    rawArgs: AssistantLifecycleArgs;
+    /** Slack auth + identity for the inbound request. */
+    auth: SlackAuthContext;
+    /**
+     * Bolt-resolved assistant thread context (channel of origin, etc.).
+     *
+     * Populated lazily on first read via `getThreadContext()`. The bridge
+     * resolves it once per turn and caches it so handlers don't have to.
+     */
+    threadContext: SlackAssistantThreadContext;
+    /**
+     * Assistant pane utilities (`setStatus`, `setSuggestedPrompts`, `setTitle`,
+     * `getThreadContext`, `saveThreadContext`).
+     */
+    assistant: SlackAssistantUtilities;
+}
+interface SlackAssistantTurnPreparation extends SlackTurnPreparation {
+}
+interface SlackAssistantStatusContext {
+    event: AgentEvent;
+    rawArgs: AssistantLifecycleArgs;
+}
+/**
+ * Configuration for the feedback block attached to assistant replies.
+ */
+interface SlackAssistantFeedbackConfig extends SlackFeedbackBlockOptions {
+    /**
+     * Called after the user clicks a feedback button. The bridge already calls
+     * `ack()` and posts an ephemeral acknowledgement (configurable below).
+     */
+    onFeedback?: SlackFeedbackHandler;
+    /** Ephemeral text shown after a positive click. Set to `false` to skip. */
+    positiveAck?: string | false;
+    /** Ephemeral text shown after a negative click. */
+    negativeAck?: string | false;
+}
+interface CreateSlackAssistantBridgeOptions {
+    /**
+     * Source of agent turns. Any object satisfying `AgentTurnSource` works:
+     * `Agent`, `InProcessAgentServer`, a runtime bridge, or a stub.
+     */
+    source: AgentTurnSource;
+    /**
+     * Custom Bolt thread context store. Defaults to Bolt's
+     * `DefaultThreadContextStore` (metadata-on-message persistence).
+     */
+    threadContextStore?: SlackAssistantThreadContextStoreLike;
+    /**
+     * Session strategy for messages routed through the assistant.
+     * The default `"thread-aware"` strategy maps Slack Assistant threads to
+     * `${channelId}:${threadTs}`, including Assistant DM threads.
+     *
+     * @default "thread-aware"
+     */
+    sessionStrategy?: SlackAssistantSessionStrategy;
+    /**
+     * Optional explicit session resolver. Returning a falsy value falls back to
+     * the configured strategy.
+     */
+    resolveSession?: (request: SlackAssistantUserMessageContext) => MaybePromise<string | undefined>;
+    /**
+     * Optional per-turn preparation hook.
+     */
+    prepareTurn?: (request: SlackAssistantUserMessageContext) => MaybePromise<SlackAssistantTurnPreparation | undefined>;
+    /**
+     * Display mode for `client.chatStream`.
+     *
+     * - `"timeline"` (default) — linear streaming, best for chat answers.
+     * - `"plan"` — task list with `task_update` chunks. Pair with the agent
+     *   emitting tool-start/tool-result events for the task UI.
+     */
+    taskDisplayMode?: SlackAssistantTaskDisplayMode;
+    /**
+     * Initial assistant pane status set immediately when a user message arrives.
+     *
+     * @default { status: "Thinking..." }
+     */
+    initialStatus?: SlackAssistantStatusUpdate | ((request: SlackAssistantUserMessageContext) => MaybePromise<SlackAssistantStatusUpdate | undefined>);
+    /**
+     * Map an AgentEvent to an assistant pane status update. Returning
+     * `undefined` keeps the previous status.
+     */
+    formatStatus?: (context: SlackAssistantStatusContext) => MaybePromise<SlackAssistantStatusUpdate | undefined>;
+    /**
+     * Suggested prompts shown when an assistant thread is opened.
+     */
+    getSuggestedPrompts?: (context: SlackAssistantThreadStartedContext) => MaybePromise<SlackAssistantSuggestedPrompts | undefined>;
+    /**
+     * Optional follow-up prompts surfaced after a successful turn completes.
+     *
+     * When provided and a non-empty result is returned, the bridge calls
+     * `assistant.threads.setSuggestedPrompts(...)` after the streaming reply
+     * has been finalized. Errors from this hook are logged and never break
+     * the turn.
+     */
+    getFollowUpPrompts?: (context: SlackAssistantUserMessageContext & {
+        finalText: string;
+    }) => MaybePromise<SlackAssistantSuggestedPrompts | undefined>;
+    /**
+     * Greeting message posted when an assistant thread is opened.
+     *
+     * @default "Hi, how can I help?"
+     */
+    getInitialReply?: (context: SlackAssistantThreadStartedContext) => MaybePromise<string | false | undefined>;
+    /**
+     * Called once per assistant turn to set the thread title via
+     * `assistant.threads.setTitle`. Return `undefined` to skip.
+     */
+    formatThreadTitle?: (request: SlackAssistantUserMessageContext) => MaybePromise<string | undefined>;
+    /**
+     * Feedback block configuration.
+     *
+     * - Object: builder + handler config (default).
+     * - `false`: omit the feedback block entirely.
+     */
+    feedback?: SlackAssistantFeedbackConfig | false;
+    /**
+     * Bridge options forwarded to `bridgeAgentEventsToSlack`. Streaming mode is
+     * pinned to `"chat-stream"` and cannot be overridden here.
+     */
+    showReasoning?: boolean;
+    /** Render root-agent tool rows/status updates. Defaults to true. */
+    showToolUsage?: boolean;
+    /** Render subagent child tool rows. Defaults to false. */
+    showSubagentToolUsage?: boolean;
+    /** Include full subagent final output in the task row. Defaults to false. */
+    showSubagentResultInTask?: boolean;
+    formatToolTitle?: (toolName: string) => string;
+    formatToolUpdate?: (toolName: string) => string;
+    formatToolDetails?: SlackEventBridgeOptions["formatToolDetails"];
+    formatToolError?: (toolName: string, error: string) => string;
+    formatReasoningUpdate?: () => string;
+    chatStreamBufferSize?: number;
+    maxTaskUpdates?: number;
+    maxTaskUpdateTextChars?: number;
+    maxTaskUpdateFieldChars?: number;
+    /**
+     * Start arguments merged into Slack's native chat stream.
+     *
+     * Use this for Slack-supported authorship fields such as `icon_emoji`,
+     * `icon_url`, and `username`. The bridge still owns channel, thread,
+     * recipient ids, task display mode, and buffer size.
+     */
+    chatStreamStartArgs?: SlackChatStreamStartArgs;
+    /**
+     * Final arguments merged into `chatStream.stop(...)`.
+     *
+     * Use this for static footer blocks such as content disclaimers. When
+     * feedback is enabled, the feedback block is appended after any configured
+     * blocks.
+     */
+    chatStreamFinalArgs?: SlackEventBridgeOptions["chatStreamFinalArgs"];
+    formatChatMarkdown?: SlackMessageFormattingOptions;
+    formatStreamError?: (error: Error) => string;
+    /**
+     * Slack-native renderer/resolver hook for approval and human-input
+     * requests. Return `true` after rendering/recording the request to keep the
+     * agent turn alive while an out-of-band Slack action resolves it.
+     */
+    handleInteractiveRequest?: SlackInteractiveRequestHandler;
+    /**
+     * Maximum time to let an assistant turn run before aborting the underlying
+     * `AgentTurnSource`.
+     *
+     * Set to `0` to disable the timeout.
+     *
+     * @default 120000
+     */
+    timeoutMs?: number;
+    /**
+     * Optional logger for bridge diagnostics.
+     */
+    logger?: Logger;
+}
+interface SlackAssistantBridge {
+    /** The Bolt `Assistant` middleware instance to pass to `app.assistant(...)`. */
+    assistant: Assistant;
+    /**
+     * Wire the assistant + feedback action handler onto a Bolt `App` in one
+     * call. Equivalent to `app.assistant(bridge.assistant)` plus the feedback
+     * action registration when feedback is enabled.
+     */
+    install(app: App): void;
+    /**
+     * The resolved feedback action id, or `undefined` when feedback is disabled.
+     */
+    feedbackActionId?: string;
+}
+
+export { type AssistantLifecycleArgs as A, type CreateSlackAssistantBridgeOptions as C, type MaybePromise as M, type SlackAssistantBridge as S, type AssistantThreadStartedArgs as a, type SlackAssistantFeedbackConfig as b, type SlackAssistantSessionStrategy as c, type SlackAssistantStatusContext as d, type SlackAssistantThreadContextStoreLike as e, type SlackAssistantThreadStartedContext as f, type SlackAssistantTurnPreparation as g, type SlackAssistantUserMessageContext as h, resolveAssistantSessionId as r };

package/dist/policy.d.ts

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

package/dist/policy.js

@@ -0,0 +1,10 @@
+import {
+  policy_exports
+} from "./chunk-2SUAW6MV.js";
+import {
+  __reExport
+} from "./chunk-I2KLQ2HA.js";
+
+// src/policy.ts
+var policy_exports2 = {};
+__reExport(policy_exports2, policy_exports);

package/dist/setup.d.ts

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

package/dist/setup.js

@@ -0,0 +1,10 @@
+import {
+  setup_exports
+} from "./chunk-645NNJIM.js";
+import {
+  __reExport
+} from "./chunk-I2KLQ2HA.js";
+
+// src/setup.ts
+var setup_exports2 = {};
+__reExport(setup_exports2, setup_exports);

package/dist/shared.d.ts

@@ -0,0 +1,129 @@
+import { SlackAmbientTurnContext } from '@cuylabs/channel-slack/core';
+export * from '@cuylabs/channel-slack/core';
+import { AgentEvent, AgentContextFragmentBuildContext, AgentContextFragmentInput, AgentContextFragmentKind, AgentContextFragmentRole, AgentContextFragmentPlacement, AgentContextFragmentLifetime, AgentContextFragmentBudgetBehavior, AgentMiddleware } from '@cuylabs/agent-core';
+import { S as SlackEventBridgeOptions } from './options-C7OYeNR-.js';
+export { r as resolveSlackEventBridgeOptions } from './options-C7OYeNR-.js';
+import './interactive-o_NZb-Xg.js';
+
+/**
+ * Slack response-sink contracts consumed by the event bridge.
+ *
+ * The adapter constructs a `SlackResponseSink` from the Bolt `say` function
+ * and `WebClient` instance available in each handler. Keeping the sink
+ * interface separate makes the bridge testable without a live Slack
+ * connection.
+ */
+type SlackStreamTaskStatus = "pending" | "in_progress" | "complete" | "error";
+type SlackStreamChunk = {
+    type: "markdown_text";
+    text: string;
+} | {
+    type: "plan_update";
+    title: string;
+} | {
+    type: "task_update";
+    id: string;
+    title: string;
+    status: SlackStreamTaskStatus;
+    details?: string;
+    output?: string;
+};
+interface SlackChatStream {
+    append(args: {
+        markdown_text?: string;
+        chunks?: SlackStreamChunk[];
+    }): Promise<unknown>;
+    stop(args?: {
+        markdown_text?: string;
+        chunks?: SlackStreamChunk[];
+    }): Promise<unknown>;
+}
+/**
+ * Minimal Slack posting interface consumed by the event bridge.
+ */
+interface SlackResponseSink {
+    /**
+     * Post a new message to the channel / thread.
+     * Returns the channel ID and message timestamp needed for updates.
+     */
+    postMessage(text: string): Promise<{
+        channel: string;
+        ts: string;
+    }>;
+    /**
+     * Update an existing message by channel + ts.
+     */
+    updateMessage(channel: string, ts: string, text: string): Promise<void>;
+    /**
+     * Create a native Slack chat stream. Required when `streamingMode` is
+     * `"chat-stream"`.
+     */
+    createChatStream?(options: {
+        bufferSize: number;
+    }): SlackChatStream;
+}
+
+/**
+ * Event bridge — maps an agent-core `AgentEvent` stream to a Slack
+ * conversation via a `SlackResponseSink`.
+ *
+ * | Mode           | Behaviour                                              |
+ * |----------------|--------------------------------------------------------|
+ * | `progressive`  | Posts a placeholder, updates it as text accumulates.   |
+ * | `accumulate`   | Collects the full response then posts it in one shot.  |
+ * | `chat-stream`  | Uses Slack's native `chat.startStream` + append + stop |
+ *
+ * The three modes share enough state (full-response accumulator, status
+ * label, last-update offset) that they live in one function. Per-mode
+ * branches are clearly labelled inside the event loop.
+ */
+
+/**
+ * Stream agent-core events to a Slack conversation via `SlackResponseSink`.
+ *
+ * @returns The full accumulated response text.
+ */
+declare function bridgeAgentEventsToSlack(events: AsyncGenerator<AgentEvent>, sink: SlackResponseSink, options: SlackEventBridgeOptions): Promise<string>;
+
+/**
+ * Interactive-request error type raised when an `approval-request` or
+ * `human-input-request` event reaches the Slack transport in a mode that
+ * does not support in-channel resolution.
+ *
+ * Hosts can catch this error to fall back to message-and-error mode or to
+ * route the request through a custom block / view flow. Future work will
+ * add a first-class Slack rendering path here.
+ */
+declare class UnsupportedSlackInteractiveRequestError extends Error {
+    readonly kind: "approval" | "human-input";
+    readonly requestId: string;
+    constructor(kind: "approval" | "human-input", requestId: string, message: string);
+}
+
+declare const DEFAULT_SLACK_CONTEXT_FRAGMENT_KEY = "slackContextFragment";
+interface SlackContextFragmentPayload extends Partial<Pick<AgentContextFragmentInput, "budgetBehavior" | "dedupeKey" | "kind" | "lifetime" | "maxChars" | "metadata" | "placement" | "role" | "source" | "title">> {
+    content: string;
+}
+interface SlackContextFragmentResolverContext {
+    slack: Readonly<SlackAmbientTurnContext>;
+    step: AgentContextFragmentBuildContext;
+}
+type SlackContextFragmentResolver = (context: SlackContextFragmentResolverContext) => AgentContextFragmentInput | SlackContextFragmentPayload | string | undefined | Promise<AgentContextFragmentInput | SlackContextFragmentPayload | string | undefined>;
+interface SlackContextFragmentMiddlewareOptions {
+    name?: string;
+    contextKey?: string;
+    resolve?: SlackContextFragmentResolver;
+    kind?: AgentContextFragmentKind;
+    role?: AgentContextFragmentRole;
+    placement?: AgentContextFragmentPlacement;
+    lifetime?: AgentContextFragmentLifetime;
+    title?: string;
+    source?: string;
+    budgetBehavior?: AgentContextFragmentBudgetBehavior;
+    maxChars?: number;
+    dedupeKey?: string | ((context: SlackContextFragmentResolverContext) => string | undefined);
+    metadata?: Record<string, unknown> | ((context: SlackContextFragmentResolverContext) => Record<string, unknown> | undefined);
+}
+declare function createSlackContextFragmentMiddleware(options?: SlackContextFragmentMiddlewareOptions): AgentMiddleware;
+
+export { DEFAULT_SLACK_CONTEXT_FRAGMENT_KEY, type SlackChatStream, type SlackContextFragmentMiddlewareOptions, type SlackContextFragmentPayload, type SlackContextFragmentResolver, type SlackContextFragmentResolverContext, SlackEventBridgeOptions, type SlackResponseSink, type SlackStreamChunk, type SlackStreamTaskStatus, UnsupportedSlackInteractiveRequestError, bridgeAgentEventsToSlack, createSlackContextFragmentMiddleware };

package/dist/shared.js

@@ -0,0 +1,20 @@
+import {
+  DEFAULT_SLACK_CONTEXT_FRAGMENT_KEY,
+  createSlackContextFragmentMiddleware
+} from "./chunk-NIPAN4KA.js";
+import {
+  UnsupportedSlackInteractiveRequestError,
+  bridgeAgentEventsToSlack,
+  resolveSlackEventBridgeOptions
+} from "./chunk-DHPD4XH5.js";
+import "./chunk-I2KLQ2HA.js";
+
+// src/shared.ts
+export * from "@cuylabs/channel-slack/core";
+export {
+  DEFAULT_SLACK_CONTEXT_FRAGMENT_KEY,
+  UnsupportedSlackInteractiveRequestError,
+  bridgeAgentEventsToSlack,
+  createSlackContextFragmentMiddleware,
+  resolveSlackEventBridgeOptions
+};

package/dist/socket.d.ts

@@ -0,0 +1,137 @@
+import { App } from '@slack/bolt';
+import { SlackDirectAuthOptions, CreateSlackSocketBoltAppOptions, SlackDirectAuthMode } from '@cuylabs/channel-slack/bolt';
+import { S as SlackAssistantBridge, C as CreateSlackAssistantBridgeOptions, b as SlackAssistantFeedbackConfig } from './options-Uf-qmQKN.js';
+import { SlackAgentAppSurfaceOptions } from './app-surface.js';
+import { SlackFeedbackHandler } from '@cuylabs/channel-slack/feedback';
+import '@cuylabs/agent-core';
+import '@slack/web-api';
+import '@cuylabs/channel-slack/core';
+import './interactive-o_NZb-Xg.js';
+import './options-C7OYeNR-.js';
+import '@cuylabs/channel-slack/assistant';
+import './types-BqRzb_Cd.js';
+import './types-Crpil4kb.js';
+
+/**
+ * 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 { mountSlackAssistantAgentSocket } from "@cuylabs/channel-slack-agent-core";
+ *
+ * await mountSlackAssistantAgentSocket({
+ *   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 MountSlackAssistantAgentSocketOptions 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 MountSlackAssistantAgentSocketResult {
+    boltApp: App;
+    bridge: SlackAssistantBridge;
+    authMode: SlackDirectAuthMode;
+}
+interface MountSlackAgentAppSocketOptions extends SlackAgentAppSurfaceOptions {
+    /**
+     * 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 MountSlackAgentAppSocketResult {
+    boltApp: App;
+    bridge: SlackAssistantBridge;
+    authMode: SlackDirectAuthMode;
+}
+declare function mountSlackAssistantAgentSocket(options: MountSlackAssistantAgentSocketOptions): Promise<MountSlackAssistantAgentSocketResult>;
+declare function mountSlackAgentAppSocket(options: MountSlackAgentAppSocketOptions): Promise<MountSlackAgentAppSocketResult>;
+
+export { type MountSlackAgentAppSocketOptions, type MountSlackAgentAppSocketResult, type MountSlackAssistantAgentSocketOptions, type MountSlackAssistantAgentSocketResult, mountSlackAgentAppSocket, mountSlackAssistantAgentSocket };

package/dist/socket.js

@@ -0,0 +1,16 @@
+import {
+  mountSlackAgentAppSocket,
+  mountSlackAssistantAgentSocket
+} from "./chunk-IWUYIAY5.js";
+import "./chunk-M64Z6TYL.js";
+import "./chunk-BFUPAJON.js";
+import "./chunk-VHGV66M7.js";
+import "./chunk-FDRQOG7Q.js";
+import "./chunk-GNXWTKQ6.js";
+import "./chunk-DHPD4XH5.js";
+import "./chunk-ANIZ5NT4.js";
+import "./chunk-I2KLQ2HA.js";
+export {
+  mountSlackAgentAppSocket,
+  mountSlackAssistantAgentSocket
+};

package/dist/targets.d.ts

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

package/dist/targets.js

@@ -0,0 +1,10 @@
+import {
+  targets_exports
+} from "./chunk-K2E6A377.js";
+import {
+  __reExport
+} from "./chunk-I2KLQ2HA.js";
+
+// src/targets.ts
+var targets_exports2 = {};
+__reExport(targets_exports2, targets_exports);