@cuylabs/channel-slack 0.9.0 → 0.11.0

package/dist/options-B0xQCaez.d.ts

@@ -0,0 +1,221 @@
+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';
+
+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;
+
+export { type SlackTurnToolErrorEvent as A, type SlackTurnToolResultEvent as B, type SlackTurnToolStartEvent as C, resolveSlackEventBridgeOptions as D, type SlackEventBridgeOptions as S, type SlackFinalResponseArtifactContext as a, type SlackFinalResponseArtifactDeliveryMode as b, type SlackFinalResponseArtifactPublisher as c, type SlackFinalResponseArtifactResult as d, type SlackTurnApprovalRequestEvent as e, type SlackTurnApprovalResolvedEvent as f, type SlackTurnCompleteEvent as g, type SlackTurnErrorEvent as h, type SlackTurnEvent as i, type SlackTurnEventBase as j, type SlackTurnHumanInputRequestEvent as k, type SlackTurnHumanInputResolvedEvent as l, type SlackTurnReasoningEndEvent as m, type SlackTurnReasoningStartEvent as n, type SlackTurnSource as o, type SlackTurnSourceChatOptions as p, type SlackTurnStatus as q, type SlackTurnStatusEvent as r, type SlackTurnSubagentCompleteEvent as s, type SlackTurnSubagentErrorEvent as t, type SlackTurnSubagentEventBase as u, type SlackTurnSubagentEventEvent as v, type SlackTurnSubagentStartEvent as w, type SlackTurnTextDeltaEvent as x, type SlackTurnTextEndEvent as y, type SlackTurnTextStartEvent as z };

package/dist/options-DQacQDmD.d.ts

@@ -0,0 +1,368 @@
+import { AssistantUserMessageMiddleware, AssistantThreadStartedMiddleware, Assistant, App } from '@slack/bolt';
+import { WebClient } from '@slack/web-api';
+import { f as SlackAuthContext, d as SlackAssistantThreadContext, e as SlackAssistantUtilities, j as SlackTurnPreparation, c as SlackAssistantTaskDisplayMode, S as SlackAssistantStatusUpdate, b as SlackAssistantSuggestedPrompts, g as SlackChatStreamStartArgs } from './turn-BGAXddH_.js';
+import { h as SlackInteractiveRequestHandler } from './interactive-CbKYkkc_.js';
+import { a as SlackMessageFormattingOptions } from './formatting-C-kwQseI.js';
+import { o as SlackTurnSource, i as SlackTurnEvent, S as SlackEventBridgeOptions } from './options-B0xQCaez.js';
+import { SlackFeedbackBlockOptions, SlackFeedbackHandler } from './feedback/index.js';
+import { S as SlackActivityInfo } from './activity-ByrD9Ftr.js';
+import { L as Logger } from './logging-Bl3HfcC8.js';
+
+/**
+ * Per-thread Assistant context store.
+ *
+ * Bolt's default store persists context in message metadata, but also keeps a
+ * single process-local cached context. That cache is not keyed by thread, so a
+ * multi-user app can read the wrong channel-of-origin context after another
+ * assistant thread changes it. This store keeps the same metadata persistence
+ * model while caching by Slack channel/thread.
+ */
+type ThreadStoreArgs = {
+    context?: {
+        botUserId?: string;
+    };
+    client?: {
+        conversations?: {
+            replies?: (args: Record<string, unknown>) => Promise<{
+                messages?: unknown[];
+            }>;
+        };
+        chat?: {
+            update?: (args: Record<string, unknown>) => Promise<unknown>;
+        };
+    };
+    logger?: {
+        debug?: (...args: unknown[]) => void;
+    };
+    payload?: unknown;
+};
+interface SlackAssistantThreadContextStoreLike {
+    get: (args: ThreadStoreArgs) => Promise<unknown>;
+    save: (args: ThreadStoreArgs) => Promise<void>;
+}
+declare function createSlackAssistantThreadContextStore(): SlackAssistantThreadContextStoreLike;
+
+/**
+ * Parse the `message` payload delivered to a Bolt assistant `userMessage`
+ * handler into the same shape as `parseSlackMessageActivity`.
+ *
+ * Bolt routes a fairly wide message event to assistant handlers, so we keep
+ * the input typed loosely and inspect only the fields we need.
+ */
+
+interface ParsedAssistantUserMessage extends SlackActivityInfo {
+    /** Slack `channel` identifier, always present after parsing. */
+    channel: string;
+    /** Slack `thread_ts` identifier — the assistant API requires a thread. */
+    threadTs: string;
+}
+/**
+ * Returns `undefined` when the event is not a parseable user message — bolt
+ * delivers join/leave/edit/delete subtypes through the same handler, and the
+ * caller should ignore them.
+ */
+declare function parseSlackMessageActivityFromMessageEvent(message: unknown): ParsedAssistantUserMessage | undefined;
+
+type SlackAssistantCancelControlVisibleWhen = "before-output" | "always-while-active";
+interface SlackAssistantCancelControlOptions {
+    actionId?: string;
+    buttonText?: string;
+    messageText?: string;
+    visibleWhen?: SlackAssistantCancelControlVisibleWhen;
+    canceledAck?: string | false;
+    alreadyCompletedAck?: string | false;
+    unauthorizedAck?: string | false;
+    onCancel?: (context: SlackAssistantTurnCancelContext) => MaybePromise<void>;
+}
+interface SlackAssistantTurnControlsOptions {
+    cancel?: true | SlackAssistantCancelControlOptions;
+}
+interface SlackAssistantTurnCancelContext {
+    controlId: string;
+    sessionId: string;
+    channelId: string;
+    threadTs: string;
+    userId: string;
+    teamId?: string;
+}
+
+/**
+ * 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>;
+/**
+ * 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
+ * Slack 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: SlackTurnEvent;
+    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 Slack turns. Any object satisfying `SlackTurnSource` works.
+     */
+    source: SlackTurnSource;
+    /**
+     * 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 SlackTurnEvent 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;
+    /**
+     * Optional active-turn controls rendered in Slack while an assistant turn is
+     * running. The cancel control aborts the underlying `SlackTurnSource` via
+     * the per-turn `AbortSignal`, so any runtime implementing that contract can
+     * participate without Slack-specific code.
+     */
+    turnControls?: SlackAssistantTurnControlsOptions;
+    /**
+     * Bridge options forwarded to `bridgeSlackTurnEventsToSlack`. 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"];
+    formatToolResultOutput?: SlackEventBridgeOptions["formatToolResultOutput"];
+    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"];
+    /**
+     * 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"];
+    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
+     * Slack 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
+     * `SlackTurnSource`.
+     *
+     * 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;
+    /**
+     * The resolved cancel action id, or `undefined` when turn cancel controls are
+     * disabled.
+     */
+    turnCancelActionId?: string;
+}
+
+export { type AssistantLifecycleArgs as A, type CreateSlackAssistantBridgeOptions as C, type MaybePromise as M, type ParsedAssistantUserMessage as P, type SlackAssistantBridge as S, type AssistantThreadStartedArgs as a, type SlackAssistantCancelControlOptions as b, type SlackAssistantCancelControlVisibleWhen as c, type SlackAssistantFeedbackConfig as d, type SlackAssistantSessionStrategy as e, type SlackAssistantStatusContext as f, type SlackAssistantThreadContextStoreLike as g, type SlackAssistantThreadStartedContext as h, type SlackAssistantTurnCancelContext as i, type SlackAssistantTurnControlsOptions as j, type SlackAssistantTurnPreparation as k, type SlackAssistantUserMessageContext as l, createSlackAssistantThreadContextStore as m, parseSlackMessageActivityFromMessageEvent as p, resolveAssistantSessionId as r };

package/dist/runtime/index.d.ts

@@ -0,0 +1,46 @@
+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';
+
+/**
+ * Event bridge — maps a runtime-neutral `SlackTurnEvent` 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 runtime-neutral turn events to a Slack conversation via
+ * `SlackResponseSink`.
+ *
+ * @returns The full accumulated response text.
+ */
+declare function bridgeSlackTurnEventsToSlack(events: AsyncGenerator<SlackTurnEvent>, 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 install
+ * `createSlackInteractiveController` to render and resolve requests in Slack.
+ */
+declare class UnsupportedSlackInteractiveRequestError extends Error {
+    readonly kind: "approval" | "human-input";
+    readonly requestId: string;
+    constructor(kind: "approval" | "human-input", requestId: string, message: string);
+}
+
+export { SlackEventBridgeOptions, SlackTurnEvent, UnsupportedSlackInteractiveRequestError, bridgeSlackTurnEventsToSlack };

package/dist/runtime/index.js

@@ -0,0 +1,10 @@
+import {
+  UnsupportedSlackInteractiveRequestError,
+  bridgeSlackTurnEventsToSlack,
+  resolveSlackEventBridgeOptions
+} from "../chunk-IAQXQESO.js";
+export {
+  UnsupportedSlackInteractiveRequestError,
+  bridgeSlackTurnEventsToSlack,
+  resolveSlackEventBridgeOptions
+};