@cuylabs/channel-slack 0.10.0 → 0.11.0

package/dist/turn-BGAXddH_.d.ts

@@ -0,0 +1,178 @@
+import { S as SlackActivityInfo, b as SlackUserIdentity } from './activity-ByrD9Ftr.js';
+
+/**
+ * Slack auth context — credentials and identifiers resolved from the inbound
+ * request. **Sensitive**: see security note on `SlackAuthContext`.
+ */
+/**
+ * Slack credentials and identifiers resolved from the inbound request.
+ *
+ * Surfaced to `prepareTurn`, the ambient `currentSlackTurnContext()`, and the
+ * assistant message context so tools and middleware can call the Slack Web
+ * API or attach per-user OAuth tokens to MCP servers (see
+ * `createSlackMcpServerConfig`).
+ *
+ * Security: `botToken` and `userToken` are secrets. Do not include this auth
+ * bag in logs, telemetry attributes, baggage, tool results, message history,
+ * or model-visible prompts. Pass only the exact token needed to a trusted
+ * Slack API/MCP client.
+ *
+ * Most fields come from Bolt's enriched `args.context`. They are all optional
+ * because availability depends on the auth mode (single-workspace vs OAuth)
+ * and on whether the installer granted user scopes.
+ */
+interface SlackAuthContext {
+    /** Workspace bot token (`xoxb-...`). */
+    botToken?: string;
+    /** End-user OAuth token (`xoxp-...`) when user scopes were granted. */
+    userToken?: string;
+    /** Workspace ID (`T...`). */
+    teamId?: string;
+    /** Enterprise grid ID (`E...`) when applicable. */
+    enterpriseId?: string;
+    /** Bot user ID (`U...`) — useful for distinguishing bot self-mentions. */
+    botUserId?: string;
+    /** Internal Slack bot ID (`B...`). */
+    botId?: string;
+    /** Slack user ID (`U...`) of the human author of the inbound event. */
+    userId?: string;
+}
+
+/**
+ * Slack assistant lifecycle types — status updates, suggested prompts, thread
+ * context, and the channel-neutral `SlackAssistantUtilities` interface that
+ * the assistant bridge surfaces ambiently for tools and middleware.
+ */
+/**
+ * Slack assistant thread context — the channel of origin metadata Slack tracks
+ * while a user navigates the workspace. Surfaces the same fields Bolt's
+ * `AssistantThreadContextStore` returns.
+ *
+ * @see https://docs.slack.dev/reference/events/assistant_thread_context_changed
+ */
+interface SlackAssistantThreadContext {
+    channel_id?: string;
+    team_id?: string;
+    enterprise_id?: string | null;
+}
+/** Display mode passed to `client.chatStream`. */
+type SlackAssistantTaskDisplayMode = "plan" | "timeline";
+/**
+ * Slack message authorship fields supported by AI assistant status updates
+ * and native chat stream start calls.
+ */
+interface SlackMessageAuthorshipOptions {
+    /** Emoji shown as the message/status icon, e.g. `":robot_face:"`. */
+    icon_emoji?: string;
+    /** Image URL shown as the message/status icon. */
+    icon_url?: string;
+    /** Display name shown for the message/status. */
+    username?: string;
+}
+/** Optional passthrough fields for Slack's native `chat.startStream`. */
+type SlackChatStreamStartArgs = SlackMessageAuthorshipOptions & {
+    /**
+     * Slack task display mode for streamed tool/task chunks. `timeline` shows
+     * individual task cards; `plan` groups task cards together.
+     */
+    task_display_mode?: SlackAssistantTaskDisplayMode;
+};
+/** A single suggested prompt chip shown in the assistant pane. */
+interface SlackAssistantSuggestedPrompt {
+    title: string;
+    message: string;
+}
+/** Suggested prompts payload for `assistant.threads.setSuggestedPrompts`. */
+interface SlackAssistantSuggestedPrompts {
+    /** Title shown above the chips. Defaults to Slack's "Try these prompts:". */
+    title?: string;
+    prompts: SlackAssistantSuggestedPrompt[];
+}
+/** Status payload accepted by Bolt's assistant `setStatus`. */
+interface SlackAssistantStatusUpdate extends SlackMessageAuthorshipOptions {
+    status: string;
+    loading_messages?: string[];
+}
+/**
+ * Assistant pane utilities surfaced ambiently so tools/middleware can call
+ * them mid-turn without wiring the raw Bolt args through.
+ *
+ * Only present when the turn is running through the assistant bridge.
+ */
+interface SlackAssistantUtilities {
+    setStatus: (update: SlackAssistantStatusUpdate) => Promise<void>;
+    setSuggestedPrompts: (prompts: SlackAssistantSuggestedPrompts) => Promise<void>;
+    setTitle: (title: string) => Promise<void>;
+    getThreadContext: () => Promise<SlackAssistantThreadContext>;
+    saveThreadContext: () => Promise<void>;
+}
+/**
+ * Status utility exposed by Bolt for any message/app_mention event with a
+ * channel + thread timestamp. It calls Slack's assistant thread status API,
+ * but unlike the full Assistant surface it does not imply suggested prompts,
+ * thread titles, or origin-channel context.
+ */
+type SlackThreadStatusSetter = (update: SlackAssistantStatusUpdate) => Promise<void>;
+
+/**
+ * Slack turn-request and turn-preparation contracts shared by Slack transport
+ * packages. Direct Slack fills these from Bolt events; M365-backed Slack fills
+ * the same shape from Bot Framework activities.
+ */
+
+/**
+ * Context available while preparing a Slack turn.
+ */
+interface SlackTurnRequestContext {
+    /** Parsed Slack activity metadata */
+    slackActivity: SlackActivityInfo;
+    /** Extracted Slack user identity */
+    user: SlackUserIdentity;
+    /** Resolved runtime session ID for this conversation */
+    sessionId: string;
+    /** Plain-text message forwarded to the host application */
+    message: string;
+    /**
+     * Slack auth + identity resolved from the inbound request.
+     *
+     * Includes the bot token, optional end-user OAuth token, team/enterprise
+     * IDs, and bot user ID. Tools and `prepareTurn` callers can use these to
+     * call the Slack Web API or attach the user token to MCP servers.
+     */
+    auth?: SlackAuthContext;
+    /**
+     * Assistant thread context resolved by Bolt for assistant-pane turns.
+     *
+     * Tells the runtime which channel/workspace the user is currently viewing
+     * while talking to the assistant — useful for context-aware system prompts
+     * and for resolving relative references like "this channel".
+     *
+     * `undefined` when the turn was not routed through the assistant bridge.
+     */
+    threadContext?: SlackAssistantThreadContext;
+    /**
+     * Slack thread status setter available when Bolt provides `setStatus` for
+     * the inbound event. This can be present on classic `app_mention` /
+     * `message` turns as well as full Assistant-pane turns.
+     */
+    setStatus?: SlackThreadStatusSetter;
+}
+/**
+ * Optional turn preparation result for a Slack turn.
+ */
+interface SlackTurnPreparation {
+    /** Optional system override for the host application */
+    system?: string;
+    /** Optional message override for the host application. */
+    message?: string;
+    /** Optional session override for this turn. */
+    sessionId?: string;
+    /** Optional custom scope name for the activity */
+    scopeName?: string;
+    /** Additional scalar attributes merged into the activity scope */
+    scopeAttributes?: Record<string, string | number | boolean | null | undefined>;
+    /** Arbitrary app-specific per-turn context exposed via AsyncLocalStorage */
+    context?: Record<string, unknown>;
+}
+
+export type { SlackAssistantStatusUpdate as S, SlackAssistantSuggestedPrompt as a, SlackAssistantSuggestedPrompts as b, SlackAssistantTaskDisplayMode as c, SlackAssistantThreadContext as d, SlackAssistantUtilities as e, SlackAuthContext as f, SlackChatStreamStartArgs as g, SlackMessageAuthorshipOptions as h, SlackThreadStatusSetter as i, SlackTurnPreparation as j, SlackTurnRequestContext as k };

package/dist/types-wLZzyI9r.d.ts

@@ -0,0 +1,375 @@
+import { S as SlackActivityInfo, b as SlackUserIdentity } from './activity-ByrD9Ftr.js';
+import { k as SlackTurnRequestContext, S as SlackAssistantStatusUpdate, g as SlackChatStreamStartArgs, j as SlackTurnPreparation } from './turn-BGAXddH_.js';
+import { h as SlackInteractiveRequestHandler } from './interactive-CbKYkkc_.js';
+import { o as SlackTurnSource, i as SlackTurnEvent, S as SlackEventBridgeOptions } from './options-B0xQCaez.js';
+import { L as Logger } from './logging-Bl3HfcC8.js';
+
+/**
+ * Channel-options + adapter contract for the direct Slack adapter
+ * (`createSlackChannelAdapter`).
+ */
+
+type HumanInputEvent = Extract<SlackTurnEvent, {
+    type: "human-input-request";
+}>["request"];
+type SlackToolStartEvent = Extract<SlackTurnEvent, {
+    type: "tool-start";
+}>;
+type SlackToolResultEvent = Extract<SlackTurnEvent, {
+    type: "tool-result";
+}>;
+type MaybePromise<T> = T | Promise<T>;
+/**
+ * Session mapping strategy.
+ *
+ * - `"thread-aware"` *(default)* — Uses the Slack thread_ts as session ID
+ *   when the message is inside a thread; falls back to the channel ID for
+ *   DMs and top-level channel messages. Produces the most natural grouping.
+ *
+ * - `"channel-id"` — Uses the Slack channel / DM ID directly. Every
+ *   message in the same channel/DM shares one session.
+ *
+ * - `"user-per-channel"` — Uses `${channelId}:${userId}`. Each user gets
+ *   an isolated session per channel/DM. Useful for private-context bots.
+ *
+ * - `"user-per-thread"` — Uses `${channelId}:${threadTs}:${userId}` for
+ *   threaded/channel messages and `${channelId}:${userId}` in DMs.
+ *
+ * - `"custom"` — Provide your own mapping via `resolveSessionId`.
+ */
+type SlackSessionStrategy = "thread-aware" | "channel-id" | "user-per-channel" | "user-per-thread" | "custom";
+/**
+ * Controls how the bot posts responses to Slack.
+ *
+ * - `"progressive"` *(default)* — Posts a placeholder message immediately,
+ *   then updates it as the agent emits text. Gives a typing-like experience.
+ *   Uses `chat.update` for mid-stream updates.
+ *
+ * - `"accumulate"` — Waits for the full response before posting. Simpler,
+ *   uses one API call, but the user sees nothing until the agent finishes.
+ *
+ * - `"chat-stream"` — Uses Slack's native `chat.startStream`,
+ *   `chat.appendStream`, and `chat.stopStream` APIs through
+ *   `WebClient.chatStream`. This is the Slack-native streaming path.
+ */
+type SlackStreamingMode = "progressive" | "accumulate" | "chat-stream";
+/**
+ * Configuration for the Slack channel adapter.
+ */
+interface SlackChannelOptions {
+    /**
+     * Generic chat turn source understood by this package.
+     */
+    source: SlackTurnSource;
+    /**
+     * How to map Slack conversations to runtime session IDs.
+     * @default "thread-aware"
+     */
+    sessionStrategy?: SlackSessionStrategy;
+    /**
+     * Custom session ID resolver. Required when `sessionStrategy` is `"custom"`.
+     */
+    resolveSessionId?: (info: SlackActivityInfo) => string | Promise<string>;
+    /**
+     * Optional full-request session resolver. Returning `undefined` falls back
+     * to `sessionStrategy` / `resolveSessionId`.
+     *
+     * Prefer this over `resolveSessionId` when session routing needs auth,
+     * prepared text, or other request metadata.
+     */
+    resolveSession?: (request: SlackTurnRequestContext) => string | undefined | Promise<string | undefined>;
+    /**
+     * Surface reasoning events as status updates in Slack.
+     * @default false
+     */
+    showReasoning?: boolean;
+    /**
+     * Surface tool usage as status updates (e.g. "Using tool: search...").
+     * This controls root-agent tool rows. Subagent child tool rows are controlled
+     * separately by `showSubagentToolUsage`.
+     * @default true
+     */
+    showToolUsage?: boolean;
+    /**
+     * Surface subagent child tool activity as Slack task rows. Disabled by
+     * default so delegated workers do not flood the parent turn timeline.
+     * Subagent start/complete/error lifecycle rows still render when
+     * `showToolUsage` is enabled.
+     * @default false
+     */
+    showSubagentToolUsage?: boolean;
+    /**
+     * Include the completed subagent output body in the subagent task row.
+     * Disabled by default because full child results should flow through
+     * `get_agent_results` and the root final answer, not the task timeline.
+     * @default false
+     */
+    showSubagentResultInTask?: boolean;
+    /**
+     * Format the tool-start status text.
+     * @default (toolName) => `🔍 Using tool: ${toolName}...`
+     */
+    formatToolUpdate?: (toolName: string) => string;
+    /**
+     * Format the title shown in Slack task cards for tool activity.
+     * @default (toolName) => toolName
+     */
+    formatToolTitle?: (toolName: string) => string;
+    /**
+     * Format task-card details for a tool-start event. Use this to show safe,
+     * redacted tool arguments in Slack's task UI.
+     * @default details use the tool-start status text
+     */
+    formatToolDetails?: (event: SlackToolStartEvent) => string | undefined;
+    /**
+     * Format completed tool output shown in Slack task cards.
+     *
+     * Return `undefined` to use the default generic formatter. Return `null` to
+     * intentionally omit output for this result.
+     */
+    formatToolResultOutput?: (event: SlackToolResultEvent) => string | null | undefined;
+    /**
+     * Format the tool-error status text.
+     * @default (toolName) => `⚠️ Tool ${toolName} encountered an error`
+     */
+    formatToolError?: (toolName: string, error: string) => string;
+    /**
+     * Format the reasoning status text.
+     * @default () => "Thinking..."
+     */
+    formatReasoningUpdate?: () => string;
+    /**
+     * Initial Slack thread status set before `prepareTurn` and `source.chat()`
+     * run, when Bolt provides `setStatus` for the classic message/app_mention
+     * listener. Use an object with `loading_messages` to enable Slack's rotating
+     * loading text.
+     *
+     * Return `undefined` from a function resolver to skip the initial status for
+     * a specific turn.
+     *
+     * @default { status: "Thinking..." }
+     */
+    initialStatus?: SlackAssistantStatusUpdate | ((request: SlackTurnRequestContext) => MaybePromise<SlackAssistantStatusUpdate | undefined>);
+    /**
+     * How to handle approval / human-input requests that Slack cannot satisfy
+     * in-channel. When `handleInteractiveRequest` is configured, the handler is
+     * tried first; this fallback is only used when the handler declines.
+     * @default "message-and-error"
+     */
+    interactiveMode?: "message-and-error" | "ignore";
+    /**
+     * Slack-native renderer/resolver hook for approval and human-input requests.
+     *
+     * The adapter provides the current Slack activity, resolved session, user,
+     * and a responder that can post/update Block Kit messages in the originating
+     * thread. Return `true` after rendering/recording the request to keep the
+     * Slack turn alive while the request is resolved out-of-band.
+     */
+    handleInteractiveRequest?: SlackInteractiveRequestHandler;
+    /**
+     * Format the fallback message shown when tool approval is required.
+     */
+    formatApprovalRequired?: (request: Extract<SlackTurnEvent, {
+        type: "approval-request";
+    }>["request"]) => string;
+    /**
+     * Format the fallback message shown when human input is required.
+     */
+    formatHumanInputRequired?: (request: HumanInputEvent) => string;
+    /**
+     * How the bot posts responses.
+     * @default "progressive"
+     */
+    streamingMode?: SlackStreamingMode;
+    /**
+     * Minimum number of accumulated characters before issuing a `chat.update`
+     * in progressive mode.
+     * @default 150
+     */
+    progressiveUpdateThreshold?: number;
+    /**
+     * Minimum time between `chat.update` calls in progressive mode.
+     *
+     * Slack recommends waiting at least 3 seconds between updates to longer
+     * messages. Set to `0` to disable time throttling.
+     *
+     * @default 3000
+     */
+    progressiveUpdateIntervalMs?: number;
+    /**
+     * Buffer size passed to Slack's `WebClient.chatStream` helper when
+     * `streamingMode` is `"chat-stream"`.
+     * @default 256
+     */
+    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.
+     *
+     * @default 200
+     */
+    maxTaskUpdates?: number;
+    /**
+     * Maximum cumulative characters from task titles/details/output that the
+     * bridge will append to one chat stream.
+     *
+     * @default 20000
+     */
+    maxTaskUpdateTextChars?: number;
+    /**
+     * Maximum characters for a single task details/output field.
+     *
+     * @default 500
+     */
+    maxTaskUpdateFieldChars?: number;
+    /**
+     * Start arguments merged into Slack's native chat stream when
+     * `streamingMode` is `"chat-stream"`; useful for Slack-supported authorship
+     * fields such as `icon_emoji`, `icon_url`, and `username`.
+     *
+     * The adapter still owns `channel`, `thread_ts`, recipient ids, and
+     * `buffer_size`.
+     */
+    chatStreamStartArgs?: SlackChatStreamStartArgs;
+    /**
+     * Final arguments merged into `chatStream.stop(...)` when
+     * `streamingMode` is `"chat-stream"`; useful for final blocks such as a
+     * feedback widget.
+     */
+    chatStreamFinalArgs?: {
+        blocks?: unknown[];
+    } & Record<string, unknown>;
+    /**
+     * Optional publisher for rich artifacts derived from the final accumulated
+     * answer, such as creating a Slack Canvas for long responses.
+     */
+    publishFinalResponseArtifact?: SlackEventBridgeOptions["publishFinalResponseArtifact"];
+    /**
+     * Controls whether final-response artifacts are supplemental or replace long
+     * Slack text with a compact artifact pointer.
+     *
+     * @default "supplemental"
+     */
+    finalResponseArtifactMode?: SlackEventBridgeOptions["finalResponseArtifactMode"];
+    /**
+     * Raw-character threshold for replacement-mode streaming suppression.
+     *
+     * @default 4000
+     */
+    finalResponseArtifactStreamThreshold?: SlackEventBridgeOptions["finalResponseArtifactStreamThreshold"];
+    /** Notice emitted when replacement mode moves the remaining response to an artifact. */
+    formatFinalResponseArtifactContinuationNotice?: SlackEventBridgeOptions["formatFinalResponseArtifactContinuationNotice"];
+    /** Compact final Slack message emitted after artifact publication succeeds. */
+    formatFinalResponseArtifactMessage?: SlackEventBridgeOptions["formatFinalResponseArtifactMessage"];
+    /** Diagnostics hook for final-response artifact publishing failures. */
+    onFinalResponseArtifactError?: SlackEventBridgeOptions["onFinalResponseArtifactError"];
+    /**
+     * Convert common markdown constructs emitted by models into Slack mrkdwn.
+     *
+     * @default true
+     */
+    formatChatMarkdown?: boolean;
+    /**
+     * Custom response text formatter. When provided, this takes precedence over
+     * the built-in markdown-to-mrkdwn conversion.
+     */
+    formatMessageText?: (text: string) => string;
+    /**
+     * Maximum time (ms) to wait for the agent before aborting.
+     * @default 120_000
+     */
+    timeout?: number;
+    /**
+     * When `true` (default), replies to channel messages are posted inside the
+     * originating thread. When `false`, replies are posted at channel level.
+     * Has no effect in DMs.
+     * @default true
+     */
+    respondInThread?: boolean;
+    /**
+     * Welcome message sent when the bot is added to a channel or DM.
+     * Set to `null` to disable.
+     */
+    welcomeMessage?: string | null;
+    /**
+     * When `true` (default), `app.event('app_mention')` is registered so the
+     * bot responds to `@mentions` in channels.
+     * @default true
+     */
+    respondToMentions?: boolean;
+    /**
+     * When `true` (default), `app.message()` is registered so the bot
+     * can respond to direct messages and, when enabled, plain channel messages.
+     *
+     * Set to `false` if you only want @mention-triggered responses.
+     * @default true
+     */
+    respondToMessages?: boolean;
+    /**
+     * When `true`, plain channel/group/thread messages from `app.message()` are
+     * forwarded into the agent. Direct messages still work through
+     * `respondToMessages`.
+     *
+     * Keep this disabled unless your Slack app intentionally listens to every
+     * visible channel message. @mentions are handled separately by
+     * `respondToMentions`.
+     * @default false
+     */
+    respondToChannelMessages?: boolean;
+    /**
+     * Resolve additional context to inject into the agent call.
+     *
+     * Use this to customize the system prompt per user, inject Slack identity,
+     * etc. Called before `source.chat()` on every message.
+     */
+    resolveUserContext?: (user: SlackUserIdentity) => {
+        system?: string;
+    } | Promise<{
+        system?: string;
+    }>;
+    /**
+     * Prepare an Slack turn from the full Slack request context.
+     *
+     * Prefer this over `resolveUserContext` when you need structured ambient
+     * context for tools/middleware or custom scope attributes.
+     */
+    prepareTurn?: (request: SlackTurnRequestContext) => SlackTurnPreparation | Promise<SlackTurnPreparation>;
+    /**
+     * Resolve the text message forwarded to `source.chat()`.
+     *
+     * Useful when the message text needs normalisation beyond mention-stripping.
+     * Return `undefined` to skip processing this message.
+     */
+    resolveMessage?: (info: SlackActivityInfo) => string | undefined | Promise<string | undefined>;
+    /**
+     * Called on unhandled errors during turn processing.
+     */
+    onError?: (error: Error, info: SlackActivityInfo) => void | Promise<void>;
+    /**
+     * Optional diagnostics logger. Used for best-effort status/update failures
+     * and classic turn utility visibility.
+     */
+    logger?: Logger;
+}
+/**
+ * Slack channel adapter returned by `createSlackChannelAdapter`.
+ */
+interface SlackChannelAdapter {
+    /**
+     * Register all message/event handlers on a Bolt `App`.
+     *
+     * ```ts
+     * const adapter = createSlackChannelAdapter({ source });
+     * adapter.mount(boltApp);
+     * ```
+     */
+    mount(app: {
+        message: (...args: any[]) => unknown;
+        event: (...args: any[]) => unknown;
+    }): void;
+    /** Resolve or look up the session ID for a given Slack activity. */
+    getSessionId(info: SlackActivityInfo): string | Promise<string>;
+}
+
+export type { SlackChannelAdapter as S, SlackChannelOptions as a, SlackSessionStrategy as b, SlackStreamingMode as c, SlackToolStartEvent as d };

package/docs/reference/exports.md

@@ -5,12 +5,16 @@ keep application code close to the package boundary it uses.
 
 | Export                                     | Depends on                                                                      | Notes                                                                    |
 | ------------------------------------------ | ------------------------------------------------------------------------------- | ------------------------------------------------------------------------ |
+| `@cuylabs/channel-slack/app`               | `@slack/bolt`, `express`                                                        | Runtime-neutral HTTP Events API mount for Slack surfaces                 |
+| `@cuylabs/channel-slack/app-surface`       | `@slack/bolt`, `@slack/web-api` types                                           | Runtime-neutral Assistant, mention, DM, feedback, and interactive mount  |
+| `@cuylabs/channel-slack/socket`            | `@slack/bolt`                                                                   | Runtime-neutral Socket Mode mount for Slack surfaces                     |
+| `@cuylabs/channel-slack/adapter`           | `@slack/bolt`, `@slack/web-api` types                                           | Runtime-neutral classic app mention, DM, and channel-message adapter     |
 | `@cuylabs/channel-slack/core`              | no Slack SDK runtime imports                                                    | Transport-neutral parsing, formatting, types, sessions, turn context     |
 | `@cuylabs/channel-slack/policy`            | `pg` only when using connection-string Postgres state                           | Message admission and in-memory/Postgres policy state                    |
 | `@cuylabs/channel-slack/history`           | `@slack/web-api` types                                                          | History reader accepts a Slack WebClient or minimal conversations client |
 | `@cuylabs/channel-slack/interactive`       | `@slack/types`; `pg` only when using connection-string Postgres storage         | Slack interactive Block Kit/modal builders and request stores            |
 | `@cuylabs/channel-slack/app-home`          | `@slack/bolt`, `@slack/types`                                                   | Slack App Home registration helper                                       |
-| `@cuylabs/channel-slack/artifacts`         | no Slack SDK runtime imports; requires a Web API-like client at call time       | Text, file, image, link, and Canvas artifact publishing                  |
+| `@cuylabs/channel-slack/artifacts`         | no Slack SDK runtime imports; requires a Web API-like client at call time       | Text, file, image, link, Canvas, and final-response artifact publishing  |
 | `@cuylabs/channel-slack/auth`              | no Slack SDK runtime imports; `pg` is not required                              | Auth option types, auth resolution, OAuth installation stores            |
 | `@cuylabs/channel-slack/responses`         | no Slack SDK runtime imports                                                    | Slack response sink and chat stream contracts for runtime adapters       |
 | `@cuylabs/channel-slack/transports`        | `@slack/bolt`, `express`; `pg` only when using connection-string Postgres locks | HTTP and Socket Mode transport helpers                                   |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cuylabs/channel-slack",
-  "version": "0.10.0",
+  "version": "0.11.0",
   "description": "Agent-runtime-agnostic Slack channel primitives for AI agents",
   "type": "module",
   "main": "./dist/index.js",
@@ -21,6 +21,21 @@
       "import": "./dist/app-home.js",
       "default": "./dist/app-home.js"
     },
+    "./adapter": {
+      "types": "./dist/adapter/index.d.ts",
+      "import": "./dist/adapter/index.js",
+      "default": "./dist/adapter/index.js"
+    },
+    "./app": {
+      "types": "./dist/app.d.ts",
+      "import": "./dist/app.js",
+      "default": "./dist/app.js"
+    },
+    "./app-surface": {
+      "types": "./dist/app-surface.d.ts",
+      "import": "./dist/app-surface.js",
+      "default": "./dist/app-surface.js"
+    },
     "./artifacts": {
       "types": "./dist/artifacts/index.d.ts",
       "import": "./dist/artifacts/index.js",
@@ -81,6 +96,11 @@
       "import": "./dist/setup/index.js",
       "default": "./dist/setup/index.js"
     },
+    "./socket": {
+      "types": "./dist/socket.d.ts",
+      "import": "./dist/socket.js",
+      "default": "./dist/socket.js"
+    },
     "./targets": {
       "types": "./dist/targets/index.d.ts",
       "import": "./dist/targets/index.js",
@@ -168,9 +188,9 @@
     "node": ">=20"
   },
   "scripts": {
-    "build": "tsup src/index.ts src/app-home.ts src/artifacts/index.ts src/core.ts src/assistant/index.ts src/auth/index.ts src/diagnostics/index.ts src/entrypoints/index.ts src/feedback/index.ts src/history/index.ts src/interactive/index.ts src/policy/index.ts src/responses/index.ts src/runtime/index.ts src/setup/index.ts src/targets/index.ts src/turn-controls/index.ts src/transports/index.ts src/transports/http/index.ts src/transports/socket/index.ts src/users/index.ts src/views/index.ts --format esm --dts --clean",
+    "build": "tsup src/index.ts src/adapter/index.ts src/app.ts src/app-home.ts src/app-surface.ts src/artifacts/index.ts src/core.ts src/assistant/index.ts src/auth/index.ts src/diagnostics/index.ts src/entrypoints/index.ts src/feedback/index.ts src/history/index.ts src/interactive/index.ts src/policy/index.ts src/responses/index.ts src/runtime/index.ts src/setup/index.ts src/socket.ts src/targets/index.ts src/turn-controls/index.ts src/transports/index.ts src/transports/http/index.ts src/transports/socket/index.ts src/users/index.ts src/views/index.ts --format esm --dts --clean",
     "clean": "rm -rf dist",
-    "dev": "tsup src/index.ts src/app-home.ts src/artifacts/index.ts src/core.ts src/assistant/index.ts src/auth/index.ts src/diagnostics/index.ts src/entrypoints/index.ts src/feedback/index.ts src/history/index.ts src/interactive/index.ts src/policy/index.ts src/responses/index.ts src/runtime/index.ts src/setup/index.ts src/targets/index.ts src/turn-controls/index.ts src/transports/index.ts src/transports/http/index.ts src/transports/socket/index.ts src/users/index.ts src/views/index.ts --format esm --dts --watch",
+    "dev": "tsup src/index.ts src/adapter/index.ts src/app.ts src/app-home.ts src/app-surface.ts src/artifacts/index.ts src/core.ts src/assistant/index.ts src/auth/index.ts src/diagnostics/index.ts src/entrypoints/index.ts src/feedback/index.ts src/history/index.ts src/interactive/index.ts src/policy/index.ts src/responses/index.ts src/runtime/index.ts src/setup/index.ts src/socket.ts src/targets/index.ts src/turn-controls/index.ts src/transports/index.ts src/transports/http/index.ts src/transports/socket/index.ts src/users/index.ts src/views/index.ts --format esm --dts --watch",
     "lint": "eslint \"src/**/*.{ts,tsx}\" \"tests/**/*.{ts,tsx}\" --max-warnings=0",
     "test": "vitest run",
     "test:watch": "vitest",