experimental-ash 0.24.1 → 0.24.2

package/dist/src/compiled/@chat-adapter/slack/index.d.ts

@@ -1,28 +1,8 @@
-import { CardElement, BaseFormatConverter, Root, AdapterPostableMessage, Logger, Adapter, ChatInstance, UserInfo, WebhookOptions, Attachment, RawMessage, EphemeralMessage, ScheduledMessage, ModalElement, EmojiValue, StreamChunk, StreamOptions, FetchOptions, FetchResult, ThreadInfo, Message, ChannelVisibility, ListThreadsOptions, ListThreadsResult, ChannelInfo, FormattedContent } from '#compiled/chat/index.js';
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { WebClient } from './_slack-web-api.js';
+import { BaseFormatConverter, Root, AdapterPostableMessage, CardElement, Logger, Adapter, ChatInstance, UserInfo, WebhookOptions, OptionsLoadResult, ModalResponse, ModalElement, LinkPreview, Message, Attachment, RawMessage, EphemeralMessage, ScheduledMessage, FileUpload, PlanModel, PlanContent, EmojiValue, StreamChunk, StreamOptions, FetchOptions, FetchResult, ThreadInfo, ChannelVisibility, ListThreadsOptions, ListThreadsResult, ChannelInfo, FormattedContent } from '#compiled/chat/index.js';
 export { EncryptedTokenData, decodeKey } from './_chat-adapter-shared.js';
 
-/**
- * Slack Block Kit converter for cross-platform cards.
- *
- * Converts CardElement to Slack Block Kit blocks.
- * @see https://api.slack.com/block-kit
- */
-
-interface SlackBlock {
-    block_id?: string;
-    type: string;
-    [key: string]: unknown;
-}
-/**
- * Convert a CardElement to Slack Block Kit blocks.
- */
-declare function cardToBlockKit(card: CardElement): SlackBlock[];
-/**
- * Generate fallback text from a card element.
- * Used when blocks aren't supported or for notifications.
- */
-declare function cardToFallbackText(card: CardElement): string;
-
 /**
  * Slack format conversion.
  *
@@ -75,6 +55,62 @@ declare class SlackFormatConverter extends BaseFormatConverter {
     private nodeToMrkdwn;
 }
 
+/**
+ * Slack Block Kit converter for cross-platform cards.
+ *
+ * Converts CardElement to Slack Block Kit blocks.
+ * @see https://api.slack.com/block-kit
+ */
+
+interface SlackBlock {
+    block_id?: string;
+    type: string;
+    [key: string]: unknown;
+}
+/**
+ * Convert a CardElement to Slack Block Kit blocks.
+ */
+declare function cardToBlockKit(card: CardElement): SlackBlock[];
+/**
+ * Generate fallback text from a card element.
+ * Used when blocks aren't supported or for notifications.
+ */
+declare function cardToFallbackText(card: CardElement): string;
+
+/**
+ * Slack modal (view) converter.
+ * Converts ModalElement to Slack Block Kit view format.
+ */
+
+interface SlackView {
+    blocks: SlackBlock[];
+    callback_id: string;
+    close?: {
+        type: "plain_text";
+        text: string;
+    };
+    notify_on_close?: boolean;
+    private_metadata?: string;
+    submit?: {
+        type: "plain_text";
+        text: string;
+    };
+    title: {
+        type: "plain_text";
+        text: string;
+    };
+    type: "modal";
+}
+interface SlackModalResponse {
+    errors?: Record<string, string>;
+    response_action?: "errors" | "update" | "push" | "clear";
+    view?: SlackView;
+}
+
+/**
+ * Slack adapter types.
+ */
+
 type SlackAdapterMode = "webhook" | "socket";
 /**
  * Bot token configuration. Can be a static string, or a function that returns
@@ -82,6 +118,12 @@ type SlackAdapterMode = "webhook" | "socket";
  * token is needed, enabling rotation or lazy retrieval from a secret manager.
  */
 type SlackBotToken = string | (() => string | Promise<string>);
+/** Data stored per Slack workspace installation */
+interface SlackInstallation {
+    botToken: string;
+    botUserId?: string;
+    teamName?: string;
+}
 interface SlackAdapterConfig {
     /** Override the Slack API base URL (e.g. "https://slack-gov.com/api/" for GovSlack). Defaults to SLACK_API_URL env var. */
     apiUrl?: string;
@@ -109,6 +151,17 @@ interface SlackAdapterConfig {
      * Defaults to `slack:installation`. The full key will be `{prefix}:{teamId}`.
      */
     installationKeyPrefix?: string;
+    /**
+     * External installation provider for multi-workspace apps using external
+     * token management (e.g., Vercel Connect). When set, the adapter bypasses
+     * internal StateAdapter storage for token lookups.
+     *
+     * For Enterprise Grid org-wide installs, `installationId` will be the
+     * enterprise ID; otherwise it will be the team ID.
+     */
+    installationProvider?: {
+        getInstallation: (installationId: string, isEnterpriseInstall: boolean) => Promise<SlackInstallation | null>;
+    };
     /** Logger instance for error reporting. Defaults to ConsoleLogger. */
     logger?: Logger;
     /** Connection mode: "webhook" (default) or "socket" */
@@ -129,8 +182,8 @@ interface SlackAdapterConfig {
      * raw body for downstream parsing — useful when the verifier needs to
      * canonicalize or substitute the verified payload.
      *
-     * When both `signingSecret` and `webhookVerifier` are specified,
-     * `signingSecret` takes precedence.
+     * `webhookVerifier` takes precedence over `signingSecret` and the
+     * `SLACK_SIGNING_SECRET` env var; when it is set, those are ignored.
      *
      * SECURITY: When this is used in place of `signingSecret`, the built-in
      * Slack timestamp tolerance check is NOT performed. Implementations are
@@ -140,16 +193,18 @@ interface SlackAdapterConfig {
      */
     webhookVerifier?: (request: Request, body: string) => unknown | Promise<unknown>;
 }
+
+/** Envelope for events forwarded from a socket mode listener via HTTP POST */
+interface SlackForwardedSocketEvent {
+    body: Record<string, unknown>;
+    eventType: string;
+    timestamp: number;
+    type: "socket_event";
+}
 interface SlackOAuthCallbackOptions {
     /** Redirect URI to send to Slack during the OAuth code exchange. */
     redirectUri?: string;
 }
-/** Data stored per Slack workspace installation */
-interface SlackInstallation {
-    botToken: string;
-    botUserId?: string;
-    teamName?: string;
-}
 /** Slack-specific thread ID data */
 interface SlackThreadId {
     channel: string;
@@ -229,52 +284,276 @@ interface SlackReactionEvent {
     type: "reaction_added" | "reaction_removed";
     user: string;
 }
+/** Slack assistant_thread_started event payload */
+interface SlackAssistantThreadStartedEvent {
+    assistant_thread: {
+        user_id: string;
+        channel_id: string;
+        thread_ts: string;
+        context: {
+            channel_id?: string;
+            team_id?: string;
+            enterprise_id?: string;
+            thread_entry_point?: string;
+            force_search?: boolean;
+        };
+    };
+    event_ts: string;
+    type: "assistant_thread_started";
+}
+/** Slack assistant_thread_context_changed event payload */
+interface SlackAssistantContextChangedEvent {
+    assistant_thread: {
+        user_id: string;
+        channel_id: string;
+        thread_ts: string;
+        context: {
+            channel_id?: string;
+            team_id?: string;
+            enterprise_id?: string;
+            thread_entry_point?: string;
+            force_search?: boolean;
+        };
+    };
+    event_ts: string;
+    type: "assistant_thread_context_changed";
+}
+/** Slack app_home_opened event payload */
+interface SlackAppHomeOpenedEvent {
+    channel: string;
+    event_ts: string;
+    tab: string;
+    type: "app_home_opened";
+    user: string;
+}
+/** Slack member_joined_channel event payload */
+interface SlackMemberJoinedChannelEvent {
+    channel: string;
+    channel_type?: string;
+    event_ts: string;
+    inviter?: string;
+    team?: string;
+    type: "member_joined_channel";
+    user: string;
+}
+/** Slack user_change event payload */
+interface SlackUserChangeEvent {
+    event_ts: string;
+    type: "user_change";
+    user: {
+        id: string;
+        name?: string;
+        real_name?: string;
+        profile?: {
+            display_name?: string;
+            real_name?: string;
+        };
+    };
+}
+/** Slack webhook payload envelope */
+interface SlackWebhookPayload {
+    challenge?: string;
+    /** Enterprise ID for Enterprise Grid org-wide installs */
+    enterprise_id?: string;
+    event?: SlackEvent | SlackReactionEvent | SlackAssistantThreadStartedEvent | SlackAssistantContextChangedEvent | SlackAppHomeOpenedEvent | SlackMemberJoinedChannelEvent | SlackUserChangeEvent;
+    event_id?: string;
+    event_time?: number;
+    /** Whether this is an Enterprise Grid org-wide install */
+    is_enterprise_install?: boolean;
+    /** Whether this event occurred in an externally shared channel (Slack Connect) */
+    is_ext_shared_channel?: boolean;
+    team_id?: string;
+    type: string;
+}
+/** Slack interactive payload (block_actions) for button clicks */
+interface SlackBlockActionsPayload {
+    actions: Array<{
+        type: string;
+        action_id: string;
+        block_id?: string;
+        value?: string;
+        action_ts?: string;
+        selected_option?: {
+            value: string;
+        };
+    }>;
+    channel: {
+        id: string;
+        name: string;
+    };
+    container: {
+        type: string;
+        message_ts: string;
+        channel_id: string;
+        is_ephemeral?: boolean;
+        thread_ts?: string;
+    };
+    message: {
+        ts: string;
+        thread_ts?: string;
+    };
+    response_url?: string;
+    trigger_id: string;
+    type: "block_actions";
+    user: {
+        id: string;
+        username: string;
+        name?: string;
+    };
+}
+interface SlackViewSubmissionPayload {
+    trigger_id: string;
+    type: "view_submission";
+    user: {
+        id: string;
+        username: string;
+        name?: string;
+    };
+    view: {
+        id: string;
+        callback_id: string;
+        private_metadata?: string;
+        state: {
+            values: Record<string, Record<string, {
+                value?: string;
+                selected_option?: {
+                    value: string;
+                };
+            }>>;
+        };
+    };
+}
+interface SlackViewClosedPayload {
+    type: "view_closed";
+    user: {
+        id: string;
+        username: string;
+        name?: string;
+    };
+    view: {
+        id: string;
+        callback_id: string;
+        private_metadata?: string;
+    };
+}
+interface SlackBlockSuggestionPayload {
+    action_id: string;
+    block_id: string;
+    team?: {
+        id: string;
+    };
+    type: "block_suggestion";
+    user: {
+        id: string;
+        username?: string;
+        name?: string;
+    };
+    value?: string;
+}
+type SlackInteractivePayload = SlackBlockActionsPayload | SlackBlockSuggestionPayload | SlackViewSubmissionPayload | SlackViewClosedPayload;
+/** Cached user info */
+interface CachedUser {
+    avatarUrl?: string;
+    displayName: string;
+    email?: string;
+    isBot?: boolean;
+    realName: string;
+}
 declare class SlackAdapter implements Adapter<SlackThreadId, unknown> {
     readonly name = "slack";
     readonly userName: string;
-    private readonly client;
-    private readonly signingSecret;
-    private readonly webhookVerifier;
-    private readonly defaultBotTokenProvider;
-    private chat;
-    private readonly logger;
-    private _botUserId;
-    private _botId;
-    private readonly formatConverter;
-    private static USER_CACHE_TTL_MS;
-    private static CHANNEL_CACHE_TTL_MS;
-    private static REVERSE_INDEX_TTL_MS;
+    protected readonly _client: WebClient;
+    protected readonly tokenClientCache: Map<string, WebClient>;
+    protected readonly slackApiUrl: string | undefined;
+    protected readonly signingSecret: string | undefined;
+    protected readonly webhookVerifier: ((request: Request, body: string) => unknown | Promise<unknown>) | undefined;
+    protected readonly defaultBotTokenProvider: (() => string | Promise<string>) | undefined;
+    protected chat: ChatInstance | null;
+    protected readonly logger: Logger;
+    protected _botUserId: string | null;
+    protected _botId: string | null;
+    protected readonly formatConverter: SlackFormatConverter;
+    protected static readonly USER_CACHE_TTL_MS: number;
+    protected static readonly CHANNEL_CACHE_TTL_MS: number;
+    protected static readonly REVERSE_INDEX_TTL_MS: number;
     /**
      * Cache of channel IDs known to be external/shared (Slack Connect).
      * Populated from `is_ext_shared_channel` in incoming webhook payloads.
      */
     private readonly _externalChannels;
-    private readonly appToken;
-    private readonly mode;
-    private readonly socketForwardingSecret;
+    protected readonly appToken: string | undefined;
+    protected readonly mode: SlackAdapterMode;
+    protected readonly socketForwardingSecret: string | undefined;
     private socketClient;
-    private readonly clientId;
-    private readonly clientSecret;
-    private readonly encryptionKey;
-    private readonly installationKeyPrefix;
-    private readonly requestContext;
+    protected readonly clientId: string | undefined;
+    protected readonly clientSecret: string | undefined;
+    protected readonly encryptionKey: Buffer | undefined;
+    protected readonly installationKeyPrefix: string;
+    protected readonly installationProvider: SlackAdapterConfig["installationProvider"];
+    protected readonly requestContext: AsyncLocalStorage<{
+        token: string;
+        botUserId?: string;
+        isExtSharedChannel?: boolean;
+        enterpriseId?: string;
+        isEnterpriseInstall?: boolean;
+    }>;
     /** Bot user ID (e.g., U_BOT_123) used for mention detection */
     get botUserId(): string | undefined;
     get isSocketMode(): boolean;
+    /**
+     * Direct access to a [`WebClient`](https://github.com/slackapi/node-slack-sdk/tree/main/packages/web-api)
+     * from `@slack/web-api` bound to the bot token for the current request
+     * context (multi-workspace) or the configured default token
+     * (single-workspace). Use for any Slack Web API call not covered by the
+     * SDK's high-level methods — for example
+     * `adapter.webClient.pins.add(...)` or
+     * `adapter.webClient.usergroups.list(...)`.
+     *
+     * Resolution order:
+     *   1. Token from the current `requestContext` (set during webhook
+     *      handling, or by `withBotToken()`).
+     *   2. The default bot token, when configured as a static string or
+     *      synchronous resolver function.
+     *
+     * Throws `AuthenticationError` if neither is available — typical causes
+     * are calling `.webClient` outside any webhook/`withBotToken()` context
+     * in multi-workspace mode, or having configured `botToken` as an async
+     * function. In the latter case wrap the work in
+     * `adapter.withBotToken(token, () => adapter.webClient...)`.
+     *
+     * @example
+     * ```ts
+     * const slack = bot.getAdapter("slack").webClient;
+     * await slack.pins.add({
+     *   channel: "C123ABC",
+     *   timestamp: "1234567890.123456",
+     * });
+     * ```
+     */
+    get webClient(): WebClient;
+    /**
+     * @deprecated Use {@link SlackAdapter.webClient | `webClient`} instead.
+     * This alias is preserved for backwards compatibility and will be
+     * removed in a future major release.
+     */
+    get client(): WebClient;
+    private getClientForToken;
     constructor(config?: SlackAdapterConfig);
     /**
      * Get the current bot token for API calls.
      * Checks request context (multi-workspace) → default token provider
      * (single-workspace) → throws.
      */
-    private getToken;
+    protected getToken(): Promise<string>;
     /**
      * Add the current token to API call options.
      * Workaround for Slack WebClient types not including `token` in per-method args.
      */
-    private withToken;
+    protected withToken<T extends Record<string, any>>(options: T): Promise<T & {
+        token: string;
+    }>;
     initialize(chat: ChatInstance): Promise<void>;
-    private installationKey;
+    protected installationKey(teamId: string): string;
     /**
      * Save a Slack workspace installation.
      * Call this from your OAuth callback route after a successful installation.
@@ -303,61 +582,71 @@ declare class SlackAdapter implements Adapter<SlackThreadId, unknown> {
      */
     withBotToken<T>(token: string, fn: () => T): T;
     /**
-     * Resolve the bot token for a team from the state adapter.
+     * Resolve the bot token for an installation from the external provider or state adapter.
+     * @param installationId - team_id or enterprise_id depending on install type
+     * @param isEnterpriseInstall - true if this is an Enterprise Grid org-wide install
      */
-    private resolveTokenForTeam;
+    protected resolveTokenForTeam(installationId: string, isEnterpriseInstall?: boolean): Promise<{
+        token: string;
+        botUserId?: string;
+    } | null>;
     /**
-     * Extract team_id from an interactive payload (form-urlencoded).
+     * Extract installation info from an interactive payload (form-urlencoded).
+     * For Enterprise Grid org-wide installs, returns enterprise_id; otherwise team_id.
      */
-    private extractTeamIdFromInteractive;
+    protected extractInstallationFromInteractive(body: string): {
+        installationId: string;
+        isEnterpriseInstall: boolean;
+        enterpriseId?: string;
+    } | null;
     /**
      * Look up user info from Slack API with caching via state adapter.
      * Returns null when the API call fails.
      */
-    private lookupUser;
+    protected lookupUser(userId: string): Promise<CachedUser | null>;
     /**
      * Look up channel name from Slack API with caching via state adapter.
      * Returns channel name, or falls back to channel ID.
      */
-    private lookupChannel;
+    protected lookupChannel(channelId: string): Promise<string>;
     getUser(userId: string): Promise<UserInfo | null>;
     handleWebhook(request: Request, options?: WebhookOptions): Promise<Response>;
     /** Extract and dispatch events from a validated payload */
-    private processEventPayload;
+    protected processEventPayload(payload: SlackWebhookPayload, options?: WebhookOptions): void;
     /**
      * Handle Slack interactive payloads (button clicks, view submissions, etc.).
      * These are sent as form-urlencoded with a `payload` JSON field.
      */
-    private handleInteractivePayload;
+    protected handleInteractivePayload(body: string, options?: WebhookOptions): Response | Promise<Response>;
     /**
      * Dispatch a pre-parsed interactive payload to the correct handler.
      * Used by both webhook and socket mode paths.
      */
-    private dispatchInteractivePayload;
+    protected dispatchInteractivePayload(payload: SlackInteractivePayload, options?: WebhookOptions): Response | Promise<Response>;
     /**
      * Handle Slack slash command payloads.
      * Slash commands are sent as form-urlencoded with command, text, user_id, channel_id, etc.
      */
-    private handleSlashCommand;
+    protected handleSlashCommand(params: URLSearchParams, options?: WebhookOptions): Promise<Response>;
     /**
      * Handle block_actions payload (button clicks in Block Kit).
      */
-    private handleBlockActions;
-    private handleBlockSuggestion;
-    private optionsLoadResponse;
-    private handleViewSubmission;
-    private handleViewClosed;
-    private modalResponseToSlack;
-    private convertModalJSX;
+    protected handleBlockActions(payload: SlackBlockActionsPayload, options?: WebhookOptions): void;
+    protected handleBlockSuggestion(payload: SlackBlockSuggestionPayload, options?: WebhookOptions): Promise<Response>;
+    protected optionsLoadResponse(result: OptionsLoadResult): Response;
+    protected handleViewSubmission(payload: SlackViewSubmissionPayload, options?: WebhookOptions): Promise<Response>;
+    protected handleViewClosed(payload: SlackViewClosedPayload, options?: WebhookOptions): void;
+    protected modalResponseToSlack(response: ModalResponse, contextId?: string): SlackModalResponse;
+    protected convertModalJSX(modal: ModalElement): ModalElement;
     /**
      * Start Socket Mode connection.
      * Creates a SocketModeClient, registers event handlers, and connects.
      */
-    private startSocketMode;
+    protected startSocketMode(): Promise<void>;
     /**
      * Route a socket mode event to the appropriate handler.
      */
-    private routeSocketEvent;
+    protected routeSocketEvent(body: Record<string, unknown>, eventType: string, ack: (response?: Record<string, unknown>) => Promise<void>, options?: WebhookOptions): Promise<void>;
     /**
      * Start a transient Socket Mode listener for serverless environments.
      * The listener maintains a WebSocket for `durationMs`, acks events, and
@@ -372,48 +661,48 @@ declare class SlackAdapter implements Adapter<SlackThreadId, unknown> {
     /**
      * Run the socket mode listener for a specified duration.
      */
-    private runSocketModeListener;
+    protected runSocketModeListener(durationMs: number, abortSignal?: AbortSignal, webhookUrl?: string, options?: WebhookOptions): Promise<void>;
     /**
      * Forward a socket mode event to the webhook endpoint.
      */
-    private forwardSocketEvent;
+    protected forwardSocketEvent(webhookUrl: string, event: SlackForwardedSocketEvent): Promise<void>;
     /**
      * Disconnect the socket mode client.
      * No-op if not connected.
      */
     disconnect(): Promise<void>;
-    private verifySignature;
+    protected verifySignature(body: string, timestamp: string | null, signature: string | null): boolean;
     /**
      * Handle message events from Slack.
      * Bot message filtering (isMe) is handled centrally by the Chat class.
      */
-    private handleMessageEvent;
-    private handleMessageChanged;
+    protected handleMessageEvent(event: SlackEvent, options?: WebhookOptions): void;
+    protected handleMessageChanged(event: SlackEvent, _options?: WebhookOptions): void;
     /**
      * Handle reaction events from Slack (reaction_added, reaction_removed).
      */
-    private handleReactionEvent;
+    protected handleReactionEvent(event: SlackReactionEvent, options?: WebhookOptions): Promise<void>;
     /**
      * Handle assistant_thread_started events from Slack's Assistants API.
      * Fires when a user opens a new assistant thread (DM with the bot).
      */
-    private handleAssistantThreadStarted;
+    protected handleAssistantThreadStarted(event: SlackAssistantThreadStartedEvent, options?: WebhookOptions): void;
     /**
      * Handle assistant_thread_context_changed events from Slack's Assistants API.
      * Fires when a user navigates to a different channel with the assistant panel open.
      */
-    private handleAssistantContextChanged;
+    protected handleAssistantContextChanged(event: SlackAssistantContextChangedEvent, options?: WebhookOptions): void;
     /**
      * Handle app_home_opened events from Slack.
      * Fires when a user opens the bot's Home tab.
      */
-    private handleAppHomeOpened;
+    protected handleAppHomeOpened(event: SlackAppHomeOpenedEvent, options?: WebhookOptions): void;
     /**
      * Handle member_joined_channel events from Slack.
      * Fires when a user (including the bot) joins a channel.
      */
-    private handleMemberJoinedChannel;
-    private handleUserChange;
+    protected handleMemberJoinedChannel(event: SlackMemberJoinedChannelEvent, options?: WebhookOptions): void;
+    protected handleUserChange(event: SlackUserChangeEvent): Promise<void>;
     /**
      * Publish a Home tab view for a user.
      * Slack API: views.publish
@@ -449,37 +738,47 @@ declare class SlackAdapter implements Adapter<SlackThreadId, unknown> {
      *   parsing historical/channel messages where mention detection doesn't
      *   apply.
      */
-    private resolveInlineMentions;
+    protected resolveInlineMentions(text: string, skipSelfMention: boolean): Promise<string>;
     /**
      * Extract link URLs from a Slack event.
      * Uses the `blocks` field (rich_text blocks with link elements) when available,
      * falling back to parsing `<url>` patterns from the text field.
      */
-    private extractLinks;
+    protected extractLinks(event: SlackEvent): LinkPreview[];
     /**
      * Create a LinkPreview for a URL. If the URL points to a Slack message,
      * includes a `fetchMessage` callback that fetches and parses the linked message.
      */
-    private createLinkPreview;
-    private parseSlackMessage;
-    private enrichLinks;
+    protected createLinkPreview(url: string): LinkPreview;
+    protected parseSlackMessage(event: SlackEvent, threadId: string, options?: {
+        skipSelfMention?: boolean;
+    }): Promise<Message<unknown>>;
+    protected enrichLinks(links: LinkPreview[], messageTs?: string): Promise<LinkPreview[]>;
     /**
      * Create an Attachment object from a Slack file.
      * Includes a fetchData method that uses the bot token for auth.
      */
-    private createAttachment;
-    private fetchSlackFile;
+    protected createAttachment(file: {
+        id?: string;
+        mimetype?: string;
+        url_private?: string;
+        name?: string;
+        size?: number;
+        original_w?: number;
+        original_h?: number;
+    }, teamId?: string): Attachment;
+    protected fetchSlackFile(url: string, token: string): Promise<Buffer>;
     rehydrateAttachment(attachment: Attachment): Attachment;
     /**
      * Resolve @name mentions in text to Slack <@USER_ID> format using the
      * reverse user cache. When multiple users share a display name, prefers
      * the one who is a participant in the given thread.
      */
-    private resolveOutgoingMentions;
+    protected resolveOutgoingMentions(text: string, threadId: string): Promise<string>;
     /**
      * Pre-process an outgoing message to resolve @name mentions before rendering.
      */
-    private resolveMessageMentions;
+    protected resolveMessageMentions(message: AdapterPostableMessage, threadId: string): Promise<AdapterPostableMessage>;
     postMessage(threadId: string, _message: AdapterPostableMessage): Promise<RawMessage<unknown>>;
     postEphemeral(threadId: string, userId: string, _message: AdapterPostableMessage): Promise<EphemeralMessage>;
     scheduleMessage(threadId: string, _message: AdapterPostableMessage, options: {
@@ -495,14 +794,17 @@ declare class SlackAdapter implements Adapter<SlackThreadId, unknown> {
      * Upload files to Slack and share them to a channel.
      * Returns the file IDs of uploaded files.
      */
-    private uploadFiles;
+    protected uploadFiles(files: FileUpload[], channel: string, threadTs?: string): Promise<string[]>;
     editMessage(threadId: string, messageId: string, _message: AdapterPostableMessage): Promise<RawMessage<unknown>>;
     postObject(threadId: string, kind: string, data: unknown): Promise<RawMessage<unknown>>;
     editObject(threadId: string, messageId: string, kind: string, data: unknown): Promise<RawMessage<unknown>>;
-    private renderPlanFallbackText;
-    private planToBlockKit;
-    private planContentToPlainText;
-    private planContentToRichText;
+    protected renderPlanFallbackText(plan: PlanModel): string;
+    protected planToBlockKit(plan: PlanModel): unknown[];
+    protected planContentToPlainText(content: PlanContent | undefined): string;
+    protected planContentToRichText(content: PlanContent | undefined): {
+        type: "rich_text";
+        elements: unknown[];
+    } | undefined;
     deleteMessage(threadId: string, messageId: string): Promise<void>;
     addReaction(threadId: string, messageId: string, emoji: EmojiValue | string): Promise<void>;
     removeReaction(threadId: string, messageId: string, emoji: EmojiValue | string): Promise<void>;
@@ -543,7 +845,7 @@ declare class SlackAdapter implements Adapter<SlackThreadId, unknown> {
      * Fetch messages in forward direction (oldest first, efficient).
      * Uses native Slack cursor pagination.
      */
-    private fetchMessagesForward;
+    protected fetchMessagesForward(channel: string, threadTs: string, threadId: string, limit: number, cursor?: string): Promise<FetchResult<unknown>>;
     /**
      * Fetch messages in backward direction (most recent first).
      *
@@ -555,7 +857,7 @@ declare class SlackAdapter implements Adapter<SlackThreadId, unknown> {
      * Note: For very large threads (>1000 messages), the first backward call
      * may not return the absolute most recent messages. This is a Slack API limitation.
      */
-    private fetchMessagesBackward;
+    protected fetchMessagesBackward(channel: string, threadTs: string, threadId: string, limit: number, cursor?: string): Promise<FetchResult<unknown>>;
     fetchThread(threadId: string): Promise<ThreadInfo>;
     /**
      * Fetch a single message by ID (timestamp).
@@ -582,7 +884,7 @@ declare class SlackAdapter implements Adapter<SlackThreadId, unknown> {
      * Synchronous message parsing without user lookup.
      * Used for parseMessage interface - falls back to user ID for username.
      */
-    private parseSlackMessageSync;
+    protected parseSlackMessageSync(event: SlackEvent, threadId: string): Message<unknown>;
     /**
      * Derive channel ID from a Slack thread ID.
      * Slack thread IDs are "slack:CHANNEL:THREAD_TS", channel ID is "slack:CHANNEL".
@@ -592,8 +894,8 @@ declare class SlackAdapter implements Adapter<SlackThreadId, unknown> {
      * Fetch channel-level messages (conversations.history, not thread replies).
      */
     fetchChannelMessages(channelId: string, options?: FetchOptions): Promise<FetchResult<unknown>>;
-    private fetchChannelMessagesForward;
-    private fetchChannelMessagesBackward;
+    protected fetchChannelMessagesForward(channel: string, limit: number, cursor?: string): Promise<FetchResult<unknown>>;
+    protected fetchChannelMessagesBackward(channel: string, limit: number, cursor?: string): Promise<FetchResult<unknown>>;
     /**
      * List threads in a Slack channel.
      * Fetches channel history and filters for messages with replies.
@@ -619,23 +921,30 @@ declare class SlackAdapter implements Adapter<SlackThreadId, unknown> {
      * - _botUserId is the user ID (U_xxx) - matches event.user
      * - _botId is the bot ID (B_xxx) - matches event.bot_id
      */
-    private isMessageFromSelf;
-    private handleSlackError;
+    protected isMessageFromSelf(event: SlackEvent): boolean;
+    protected handleSlackError(error: unknown): never;
     /**
      * Encode response_url and userId into messageId for ephemeral messages.
      * This allows edit/delete operations to work via response_url.
      */
-    private encodeEphemeralMessageId;
+    protected encodeEphemeralMessageId(messageTs: string, responseUrl: string, userId: string): string;
     /**
      * Decode ephemeral messageId to extract messageTs, responseUrl, and userId.
      * Returns null if the messageId is not an ephemeral encoding.
      */
-    private decodeEphemeralMessageId;
+    protected decodeEphemeralMessageId(messageId: string): {
+        messageTs: string;
+        responseUrl: string;
+        userId: string;
+    } | null;
     /**
      * Send a request to Slack's response_url to modify an ephemeral message.
      */
-    private sendToResponseUrl;
+    protected sendToResponseUrl(responseUrl: string, action: "replace" | "delete", options?: {
+        message?: AdapterPostableMessage;
+        threadTs?: string;
+    }): Promise<Record<string, unknown>>;
 }
-declare function createSlackAdapter(config?: Partial<SlackAdapterConfig>): SlackAdapter;
+declare function createSlackAdapter(config?: SlackAdapterConfig): SlackAdapter;
 
 export { SlackAdapter, type SlackAdapterConfig, type SlackAdapterMode, type SlackBotToken, type SlackEvent, SlackFormatConverter, type SlackInstallation, SlackFormatConverter as SlackMarkdownConverter, type SlackOAuthCallbackOptions, type SlackReactionEvent, type SlackThreadId, cardToBlockKit, cardToFallbackText, createSlackAdapter };