@cuylabs/channel-slack 0.10.0 → 0.12.0

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/README.md

@@ -15,6 +15,7 @@ your adapter or application needs.
 - [Activity parsing](concepts/activity.md)
 - [Artifacts](concepts/artifacts.md)
 - [Entrypoints](concepts/entrypoints.md)
+- [Interactive requests](concepts/interactive-requests.md)
 - [Message policy](concepts/message-policy.md)
 - [Setup requirements](concepts/setup-requirements.md)
 - [Supplemental history](concepts/supplemental-history.md)

package/docs/concepts/interactive-requests.md

@@ -0,0 +1,85 @@
+# Interactive Requests
+
+Slack interactive requests render approval and human-input requests as Slack
+buttons and modals. The controller is runtime-neutral; applications adapt their
+runtime's request shapes into the generic Slack request types exported from
+`@cuylabs/channel-slack/interactive`.
+
+Use this import path for both generic Slack runtimes and runtime adapters such
+as `@cuylabs/channel-slack-agent-core`:
+
+```typescript
+import {
+  createPostgresSlackInteractiveRequestStore,
+  createSlackInteractiveController,
+} from "@cuylabs/channel-slack/interactive";
+import { mountSlackAppSocket } from "@cuylabs/channel-slack/socket";
+
+const interactiveStore = createPostgresSlackInteractiveRequestStore({
+  connectionString: process.env.DATABASE_URL,
+  schema: "agent",
+});
+
+const interactive = createSlackInteractiveController({
+  store: interactiveStore,
+  namespace: "my_agent_slack",
+  requestTimeoutMs: 5 * 60 * 1000,
+});
+
+await mountSlackAppSocket({
+  source,
+  interactive,
+  appToken: process.env.SLACK_APP_TOKEN,
+  botToken: process.env.SLACK_BOT_TOKEN,
+});
+```
+
+`mountSlackApp`, `mountSlackAppSocket`, and `installSlackAppSurface` install the
+controller on the Bolt app and route approval/human-input events to
+`handleInteractiveRequest`. If you manually compose lower-level Bolt helpers,
+call `interactive.install(boltApp)` and pass
+`interactive.handleInteractiveRequest` to the Slack runtime or adapter options.
+
+## Runtime Hooks
+
+The controller exposes request hooks for runtimes that own approval and
+human-input decisions:
+
+```typescript
+const approval = interactive.approval.onRequest;
+const humanInput = interactive.humanInput.onRequest;
+```
+
+Use those hooks at the runtime boundary where your agent pauses for an approval
+or human response. The Slack package deliberately keeps the request shapes
+generic; runtime-specific adapters should map their event/request types before
+calling the controller.
+
+Request IDs must be unique across pending approval and human-input requests.
+The controller rejects reuse of the same ID for a different request kind so one
+Slack button cannot resolve the wrong runtime wait.
+
+## Resolution Behavior
+
+The controller persists pending requests before rendering Slack buttons. Once a
+request is resolved, duplicate button clicks return the stored first-wins
+resolution and do not overwrite it. Resolved records are not rendered again if
+the same event is replayed.
+
+By default, only the Slack user who triggered the original turn can resolve the
+request. Pass `authorize(record, actor)` to allow delegated approvers, channel
+owners, or workspace-admin policy.
+
+## Store Choices
+
+- `createInMemorySlackInteractiveRequestStore` is useful for tests and local
+  single-process apps.
+- `createPostgresSlackInteractiveRequestStore` persists pending requests across
+  restarts and lets multiple Slack workers resolve the same request safely.
+
+The Postgres store uses one table keyed by request ID. `resolve(...)` is
+idempotent: the first resolution wins, and later duplicate button clicks return
+the original resolution without overwriting it.
+
+Call `close()` during shutdown when the store owns its `pg` pool. Call
+`prune()` manually when you disable the background prune timer.

package/docs/reference/channel-slack-boundary.md

@@ -25,8 +25,8 @@ contracts.
 - Target parsing and resolution.
 - Feedback blocks and action handler.
 - Slack response sink and chat stream contracts for runtime adapters.
-- Slack interactive request Block Kit/modal builders and in-memory/Postgres
-  stores.
+- Slack interactive request Block Kit/modal builders, in-memory/Postgres stores,
+  and controller.
 - Slack message policy resolver and in-memory/Postgres state stores.
 - Supplemental history reader, context loader, and visibility policy.
 - Assistant message parser and thread-context store.
@@ -37,7 +37,10 @@ contracts.
 - Agent-runtime scopes and context-fragment middleware.
 - Runtime-specific mapping from Slack entrypoints into an agent turn.
 - Agent event stream rendering and runtime-specific response orchestration.
-- Agent-specific approval and human-input controllers.
+- Runtime-specific mapping from approval and human-input requests into the
+  generic Slack interactive request shapes.
+- Runtime-specific wiring of `approval.onRequest` and `humanInput.onRequest`
+  into an agent runtime.
 - Product prompts, tools, audit policy, and deployment policy.
 
 Those pieces belong in runtime-specific adapters or product applications.

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/interactive`       | `@slack/bolt`, `@slack/types`; `pg` only when using connection-string storage   | Slack interactive controller, Block Kit/modal builders, and 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/docs/reference/source-layout.md

@@ -21,6 +21,7 @@ src/
     reader.ts             Slack history API reader and prompt formatter
     visibility-policy.ts  model-visible history filters
     inclusion-policy.ts   direct-message supplemental-history inclusion policy
+  interactive/            approval/human-input controller, blocks, stores
   policy/
     message/              message admission and state-store component
   setup/                  scopes, events, manifests, setup inspection

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cuylabs/channel-slack",
-  "version": "0.10.0",
+  "version": "0.12.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",

package/dist/chunk-ISOMBQXE.js

@@ -1,89 +0,0 @@
-// src/shared/turn-context.ts
-import { AsyncLocalStorage } from "async_hooks";
-var store = new AsyncLocalStorage();
-function currentSlackTurnContext() {
-  return store.getStore();
-}
-function runWithSlackTurnContext(value, fn) {
-  return Promise.resolve(store.run({ ...value }, fn));
-}
-
-// src/shared/follow-up.ts
-function formatSlackAttributedFollowUp(message) {
-  const slack = currentSlackTurnContext();
-  if (!slack) {
-    return message;
-  }
-  const sender = formatSlackSender(slack);
-  const conversation = formatSlackConversation(slack);
-  if (!sender && !conversation) {
-    return message;
-  }
-  const lines = ["Additional Slack follow-up for the running request."];
-  if (sender) {
-    lines.push(`Sender: ${sender}`);
-  }
-  if (conversation) {
-    lines.push(`Conversation: ${conversation}`);
-  }
-  lines.push("Message:", message);
-  return lines.join("\n");
-}
-function formatSlackSender(slack) {
-  const userId = slack.slackActivity.userId || slack.user.userId;
-  const displayName = readPreparedSlackDisplayName(slack.context) ?? slack.user.userName;
-  if (displayName && userId) {
-    return `${displayName} (${userId})`;
-  }
-  return displayName ?? userId ?? "unknown Slack user";
-}
-function formatSlackConversation(slack) {
-  const activity = slack.slackActivity;
-  const surface = formatSlackSurface(activity.channelType);
-  const parts = [
-    activity.teamId ? `team ${activity.teamId}` : void 0,
-    activity.channelId ? `channel ${activity.channelId}` : void 0,
-    activity.threadTs ? `thread ${activity.threadTs}` : activity.messageTs ? `message ${activity.messageTs}` : void 0
-  ].filter((part) => Boolean(part));
-  return parts.length > 0 ? `${surface} (${parts.join(", ")})` : surface;
-}
-function formatSlackSurface(channelType) {
-  switch (channelType) {
-    case "dm":
-      return "private Slack DM";
-    case "thread":
-      return "shared Slack thread";
-    case "channel":
-      return "shared Slack channel";
-    case "group":
-      return "shared Slack group conversation";
-    default:
-      return "Slack conversation";
-  }
-}
-function readPreparedSlackDisplayName(context) {
-  const slack = context?.slack;
-  if (!slack || typeof slack !== "object") {
-    return void 0;
-  }
-  const value = slack.userDisplayName;
-  return typeof value === "string" && value.length > 0 ? value : void 0;
-}
-
-// src/shared/session.ts
-function resolveThreadAwareSlackSessionId(info) {
-  if (info.channelType === "dm") {
-    return info.channelId;
-  }
-  if (info.threadTs) {
-    return `${info.channelId}:${info.threadTs}`;
-  }
-  return `${info.channelId}:${info.messageTs ?? info.channelId}`;
-}
-
-export {
-  currentSlackTurnContext,
-  runWithSlackTurnContext,
-  formatSlackAttributedFollowUp,
-  resolveThreadAwareSlackSessionId
-};