experimental-ash 0.8.3 → 0.9.0

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

@@ -1,63 +1,641 @@
-import type { Adapter, Logger } from "#compiled/chat/index.js";
+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';
+export { EncryptedTokenData, decodeKey } from './_chat-adapter-shared.js';
 
-export type SlackAdapterMode = "webhook" | "socket";
-export type SlackBotToken = string | (() => string | Promise<string>);
+/**
+ * Slack Block Kit converter for cross-platform cards.
+ *
+ * Converts CardElement to Slack Block Kit blocks.
+ * @see https://api.slack.com/block-kit
+ */
 
-export interface SlackAdapterConfig {
-  apiUrl?: string | undefined;
-  appToken?: string | undefined;
-  botToken?: SlackBotToken | undefined;
-  botUserId?: string | undefined;
-  clientId?: string | undefined;
-  clientSecret?: string | undefined;
-  encryptionKey?: string | undefined;
-  installationKeyPrefix?: string | undefined;
-  logger?: Logger | undefined;
-  mode?: SlackAdapterMode | undefined;
-  signingSecret?: string | undefined;
-  socketForwardingSecret?: string | undefined;
-  userName?: string | undefined;
-  webhookVerifier?: ((request: Request, body: string) => unknown | Promise<unknown>) | undefined;
+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;
 
-export interface SlackThreadId {
-  channel: string;
-  threadTs: string;
-}
+/**
+ * Slack format conversion.
+ *
+ * Outgoing: Slack now natively renders markdown via the `markdown_text` field
+ * on chat.postMessage / postEphemeral / update / scheduleMessage. We pass
+ * markdown through there and let Slack handle it. Interactive `response_url`
+ * payloads do not accept `markdown_text`, so those still use Slack mrkdwn text.
+ *
+ * Incoming: Slack `message` events still deliver text as mrkdwn
+ * (`*bold*`, `<@U123>`, `<url|text>`), so the toAst parser stays.
+ */
 
-export interface SlackEvent {
-  attachments?: Array<Record<string, unknown>> | undefined;
-  blocks?: Array<Record<string, unknown>> | undefined;
-  bot_id?: string | undefined;
-  channel?: string | undefined;
-  channel_type?: string | undefined;
-  edited?: { ts: string } | undefined;
-  files?: Array<{
-    id?: string | undefined;
-    mimetype?: string | undefined;
-    url_private?: string | undefined;
-    name?: string | undefined;
-    size?: number | undefined;
-    original_w?: number | undefined;
-    original_h?: number | undefined;
-  }> | undefined;
-  hidden?: boolean | undefined;
-  latest_reply?: string | undefined;
-  message?: SlackEvent | undefined;
-  reply_count?: number | undefined;
-  subtype?: string | undefined;
-  team?: string | undefined;
-  team_id?: string | undefined;
-  text?: string | undefined;
-  thread_ts?: string | undefined;
-  ts?: string | undefined;
-  type: string;
-  user?: string | undefined;
-  username?: string | undefined;
+type SlackTextPayload = {
+    text: string;
+} | {
+    markdown_text: string;
+};
+declare class SlackFormatConverter extends BaseFormatConverter {
+    /**
+     * Render an AST to standard markdown. Slack accepts this directly via
+     * `markdown_text` and the `markdown` block.
+     */
+    fromAst(ast: Root): string;
+    /**
+     * Parse Slack mrkdwn into an AST. Used for incoming `message` events.
+     */
+    toAst(mrkdwn: string): Root;
+    /**
+     * Build the Slack API payload fields for a message.
+     *
+     * - `string` / `{ raw }` → `{ text }` (plain — preserves literal `*`, `_`, etc.)
+     * - `{ markdown }` / `{ ast }` → `{ markdown_text }` (Slack renders natively)
+     *
+     * Bare `@user` mentions are rewritten to `<@user>` and `:emoji:` placeholders
+     * are normalized for Slack in all branches.
+     *
+     * Note: `markdown_text` has a 12,000 character limit; `text` allows ~40,000.
+     * Note: `markdown_text` is mutually exclusive with `text` and `blocks`.
+     */
+    toSlackPayload(message: AdapterPostableMessage): SlackTextPayload;
+    /**
+     * Build text for Slack response_url payloads.
+     *
+     * Slack rejects `markdown_text` on response_url (`no_text`), so markdown/AST
+     * messages are rendered to Slack's legacy mrkdwn format for this surface.
+     */
+    toResponseUrlText(message: AdapterPostableMessage): string;
+    private finalize;
+    private astToMrkdwn;
+    private nodeToMrkdwn;
 }
 
-export interface SlackAdapter extends Adapter<SlackThreadId, unknown> {
-  decodeThreadId(threadId: string): SlackThreadId;
+type SlackAdapterMode = "webhook" | "socket";
+/**
+ * Bot token configuration. Can be a static string, or a function that returns
+ * a token (optionally asynchronously). The function is invoked each time a
+ * token is needed, enabling rotation or lazy retrieval from a secret manager.
+ */
+type SlackBotToken = string | (() => string | Promise<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;
+    /** App-level token (xapp-...). Required for socket mode. */
+    appToken?: string;
+    /**
+     * Bot token (xoxb-...). Required for single-workspace mode. Omit for multi-workspace.
+     * May be a string, or a function returning a string or Promise<string> (called
+     * on each use to support rotation or deferred resolution).
+     */
+    botToken?: SlackBotToken;
+    /** Bot user ID (will be fetched if not provided) */
+    botUserId?: string;
+    /** Slack app client ID (required for OAuth / multi-workspace) */
+    clientId?: string;
+    /** Slack app client secret (required for OAuth / multi-workspace) */
+    clientSecret?: string;
+    /**
+     * Base64-encoded 32-byte AES-256-GCM encryption key.
+     * If provided, bot tokens stored via setInstallation() will be encrypted at rest.
+     */
+    encryptionKey?: string;
+    /**
+     * Prefix for the state key used to store workspace installations.
+     * Defaults to `slack:installation`. The full key will be `{prefix}:{teamId}`.
+     */
+    installationKeyPrefix?: string;
+    /** Logger instance for error reporting. Defaults to ConsoleLogger. */
+    logger?: Logger;
+    /** Connection mode: "webhook" (default) or "socket" */
+    mode?: SlackAdapterMode;
+    /** Signing secret for webhook verification. Defaults to SLACK_SIGNING_SECRET env var. */
+    signingSecret?: string;
+    /** Shared secret for authenticating forwarded socket mode events. Auto-detected from SLACK_SOCKET_FORWARDING_SECRET. Falls back to appToken if not set. */
+    socketForwardingSecret?: string;
+    /** Override bot username (optional) */
+    userName?: string;
+    /**
+     * Custom webhook verifier. Used in place of `signingSecret`.
+     * Receives the incoming `Request` and the raw body text already
+     * read by the adapter. To reject the request, either
+     * return a falsy value (sync or async) or throw/reject; the adapter will
+     * respond with `401 Invalid signature`. Any truthy return value is treated
+     * as a successful verification. If a string is returned, it replaces the
+     * 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.
+     *
+     * SECURITY: When this is used in place of `signingSecret`, the built-in
+     * Slack timestamp tolerance check is NOT performed. Implementations are
+     * responsible for verifying the `x-slack-request-timestamp` header (or an
+     * equivalent freshness signal) to prevent replay of captured signed
+     * requests.
+     */
+    webhookVerifier?: (request: Request, body: string) => unknown | Promise<unknown>;
+}
+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;
+    threadTs: string;
+}
+/** Slack event payload (raw message format) */
+interface SlackEvent {
+    /** Legacy attachments (unfurl previews, app unfurls, etc.) */
+    attachments?: Array<{
+        from_url?: string;
+        image_url?: string;
+        is_msg_unfurl?: boolean;
+        original_url?: string;
+        service_icon?: string;
+        service_name?: string;
+        text?: string;
+        thumb_url?: string;
+        title?: string;
+        title_link?: string;
+    }>;
+    /** Rich text blocks containing structured elements (links, mentions, etc.) */
+    blocks?: Array<{
+        type: string;
+        elements?: Array<{
+            type: string;
+            elements?: Array<{
+                type: string;
+                url?: string;
+                text?: string;
+            }>;
+        }>;
+    }>;
+    bot_id?: string;
+    channel?: string;
+    /** Channel type: "channel", "group", "mpim", or "im" (DM) */
+    channel_type?: string;
+    edited?: {
+        ts: string;
+    };
+    files?: Array<{
+        id?: string;
+        mimetype?: string;
+        url_private?: string;
+        name?: string;
+        size?: number;
+        original_w?: number;
+        original_h?: number;
+    }>;
+    /** Hidden flag on message_changed events (true for unfurl-only updates) */
+    hidden?: boolean;
+    /** Timestamp of the latest reply (present on thread parent messages) */
+    latest_reply?: string;
+    /** Inner message on message_changed events */
+    message?: SlackEvent;
+    /** Number of replies in the thread (present on thread parent messages) */
+    reply_count?: number;
+    subtype?: string;
+    team?: string;
+    team_id?: string;
+    text?: string;
+    thread_ts?: string;
+    ts?: string;
+    type: string;
+    user?: string;
+    username?: string;
+}
+/** Slack reaction event payload */
+interface SlackReactionEvent {
+    event_ts: string;
+    item: {
+        type: string;
+        channel: string;
+        ts: string;
+    };
+    item_user?: string;
+    reaction: string;
+    type: "reaction_added" | "reaction_removed";
+    user: 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;
+    /**
+     * 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;
+    private socketClient;
+    private readonly clientId;
+    private readonly clientSecret;
+    private readonly encryptionKey;
+    private readonly installationKeyPrefix;
+    private readonly requestContext;
+    /** Bot user ID (e.g., U_BOT_123) used for mention detection */
+    get botUserId(): string | undefined;
+    get isSocketMode(): boolean;
+    constructor(config?: SlackAdapterConfig);
+    /**
+     * Get the current bot token for API calls.
+     * Checks request context (multi-workspace) → default token provider
+     * (single-workspace) → throws.
+     */
+    private getToken;
+    /**
+     * Add the current token to API call options.
+     * Workaround for Slack WebClient types not including `token` in per-method args.
+     */
+    private withToken;
+    initialize(chat: ChatInstance): Promise<void>;
+    private installationKey;
+    /**
+     * Save a Slack workspace installation.
+     * Call this from your OAuth callback route after a successful installation.
+     */
+    setInstallation(teamId: string, installation: SlackInstallation): Promise<void>;
+    /**
+     * Retrieve a Slack workspace installation.
+     */
+    getInstallation(teamId: string): Promise<SlackInstallation | null>;
+    /**
+     * Handle the Slack OAuth V2 callback.
+     * Accepts the incoming request, extracts the authorization code,
+     * exchanges it for tokens, and saves the installation.
+     */
+    handleOAuthCallback(request: Request, options?: SlackOAuthCallbackOptions): Promise<{
+        teamId: string;
+        installation: SlackInstallation;
+    }>;
+    /**
+     * Remove a Slack workspace installation.
+     */
+    deleteInstallation(teamId: string): Promise<void>;
+    /**
+     * Run a function with a specific bot token in context.
+     * Use this for operations outside webhook handling (cron jobs, workflows).
+     */
+    withBotToken<T>(token: string, fn: () => T): T;
+    /**
+     * Resolve the bot token for a team from the state adapter.
+     */
+    private resolveTokenForTeam;
+    /**
+     * Extract team_id from an interactive payload (form-urlencoded).
+     */
+    private extractTeamIdFromInteractive;
+    /**
+     * Look up user info from Slack API with caching via state adapter.
+     * Returns null when the API call fails.
+     */
+    private lookupUser;
+    /**
+     * Look up channel name from Slack API with caching via state adapter.
+     * Returns channel name, or falls back to channel ID.
+     */
+    private lookupChannel;
+    getUser(userId: string): Promise<UserInfo | null>;
+    handleWebhook(request: Request, options?: WebhookOptions): Promise<Response>;
+    /** Extract and dispatch events from a validated payload */
+    private processEventPayload;
+    /**
+     * Handle Slack interactive payloads (button clicks, view submissions, etc.).
+     * These are sent as form-urlencoded with a `payload` JSON field.
+     */
+    private handleInteractivePayload;
+    /**
+     * Dispatch a pre-parsed interactive payload to the correct handler.
+     * Used by both webhook and socket mode paths.
+     */
+    private dispatchInteractivePayload;
+    /**
+     * Handle Slack slash command payloads.
+     * Slash commands are sent as form-urlencoded with command, text, user_id, channel_id, etc.
+     */
+    private handleSlashCommand;
+    /**
+     * Handle block_actions payload (button clicks in Block Kit).
+     */
+    private handleBlockActions;
+    private handleBlockSuggestion;
+    private optionsLoadResponse;
+    private handleViewSubmission;
+    private handleViewClosed;
+    private modalResponseToSlack;
+    private convertModalJSX;
+    /**
+     * Start Socket Mode connection.
+     * Creates a SocketModeClient, registers event handlers, and connects.
+     */
+    private startSocketMode;
+    /**
+     * Route a socket mode event to the appropriate handler.
+     */
+    private routeSocketEvent;
+    /**
+     * Start a transient Socket Mode listener for serverless environments.
+     * The listener maintains a WebSocket for `durationMs`, acks events, and
+     * forwards them via HTTP POST to the webhook endpoint (or processes directly).
+     *
+     * @param options - Webhook options with waitUntil function
+     * @param durationMs - How long to keep listening (default: 180000ms = 3 minutes)
+     * @param abortSignal - Optional signal to stop the listener early
+     * @param webhookUrl - URL to forward socket events to (required for forwarding mode)
+     */
+    startSocketModeListener(options: WebhookOptions, durationMs?: number, abortSignal?: AbortSignal, webhookUrl?: string): Promise<Response>;
+    /**
+     * Run the socket mode listener for a specified duration.
+     */
+    private runSocketModeListener;
+    /**
+     * Forward a socket mode event to the webhook endpoint.
+     */
+    private forwardSocketEvent;
+    /**
+     * Disconnect the socket mode client.
+     * No-op if not connected.
+     */
+    disconnect(): Promise<void>;
+    private verifySignature;
+    /**
+     * Handle message events from Slack.
+     * Bot message filtering (isMe) is handled centrally by the Chat class.
+     */
+    private handleMessageEvent;
+    private handleMessageChanged;
+    /**
+     * Handle reaction events from Slack (reaction_added, reaction_removed).
+     */
+    private handleReactionEvent;
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * Handle app_home_opened events from Slack.
+     * Fires when a user opens the bot's Home tab.
+     */
+    private handleAppHomeOpened;
+    /**
+     * Handle member_joined_channel events from Slack.
+     * Fires when a user (including the bot) joins a channel.
+     */
+    private handleMemberJoinedChannel;
+    private handleUserChange;
+    /**
+     * Publish a Home tab view for a user.
+     * Slack API: views.publish
+     */
+    publishHomeView(userId: string, view: Record<string, unknown>): Promise<void>;
+    /**
+     * Set suggested prompts for an assistant thread.
+     * Slack Assistants API: assistant.threads.setSuggestedPrompts
+     */
+    setSuggestedPrompts(channelId: string, threadTs: string, prompts: Array<{
+        title: string;
+        message: string;
+    }>, title?: string): Promise<void>;
+    /**
+     * Set status/thinking indicator for an assistant thread.
+     * Slack Assistants API: assistant.threads.setStatus
+     */
+    setAssistantStatus(channelId: string, threadTs: string, status: string, loadingMessages?: string[]): Promise<void>;
+    /**
+     * Set title for an assistant thread (shown in History tab).
+     * Slack Assistants API: assistant.threads.setTitle
+     */
+    setAssistantTitle(channelId: string, threadTs: string, title: string): Promise<void>;
+    /**
+     * Resolve inline user mentions in Slack mrkdwn text.
+     * Converts <@U123> to <@U123|displayName> so that toAst/extractPlainText
+     * renders them as @displayName instead of @U123.
+     *
+     * @param skipSelfMention - When true, skips the bot's own user ID so that
+     *   mention detection (which looks for @botUserId in the text) continues to
+     *   work. Uses the effective request-scoped bot user ID in multi-workspace
+     *   mode, not only the adapter's default bot user ID. Set to false when
+     *   parsing historical/channel messages where mention detection doesn't
+     *   apply.
+     */
+    private resolveInlineMentions;
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * Create an Attachment object from a Slack file.
+     * Includes a fetchData method that uses the bot token for auth.
+     */
+    private createAttachment;
+    private fetchSlackFile;
+    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;
+    /**
+     * Pre-process an outgoing message to resolve @name mentions before rendering.
+     */
+    private resolveMessageMentions;
+    postMessage(threadId: string, _message: AdapterPostableMessage): Promise<RawMessage<unknown>>;
+    postEphemeral(threadId: string, userId: string, _message: AdapterPostableMessage): Promise<EphemeralMessage>;
+    scheduleMessage(threadId: string, _message: AdapterPostableMessage, options: {
+        postAt: Date;
+    }): Promise<ScheduledMessage>;
+    openModal(triggerId: string, modal: ModalElement, contextId?: string): Promise<{
+        viewId: string;
+    }>;
+    updateModal(viewId: string, modal: ModalElement): Promise<{
+        viewId: string;
+    }>;
+    /**
+     * Upload files to Slack and share them to a channel.
+     * Returns the file IDs of uploaded files.
+     */
+    private uploadFiles;
+    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;
+    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>;
+    /**
+     * Show typing indicator with optional custom status.
+     *
+     * When status is provided, uses Slack's assistant.threads.setStatus API
+     * to show custom loading text (requires Agents & AI Apps feature and assistant:write scope).
+     * The status auto-clears when a message is posted to the thread.
+     *
+     * When status is not provided, defaults to "Typing..." with default loading messages.
+     *
+     * @param threadId - The thread to show the indicator in
+     * @param status - Optional custom status message (e.g., "Searching documents...")
+     */
+    startTyping(threadId: string, status?: string): Promise<void>;
+    /**
+     * Stream a message using Slack's native streaming API.
+     *
+     * Consumes an async iterable of text chunks and/or structured StreamChunk
+     * objects (task_update, plan_update, markdown_text) and streams them to Slack.
+     *
+     * Plain strings are rendered through StreamingMarkdownRenderer for safe
+     * incremental markdown. StreamChunk objects are passed directly to Slack's
+     * streaming API as chunk payloads, enabling native task progress cards
+     * and plan displays in the Slack AI Assistant UI.
+     *
+     * Requires `recipientUserId` and `recipientTeamId` in options.
+     */
+    stream(threadId: string, textStream: AsyncIterable<string | StreamChunk>, options?: StreamOptions): Promise<RawMessage<unknown>>;
+    /**
+     * Open a direct message conversation with a user.
+     * Returns a thread ID that can be used to post messages.
+     */
+    openDM(userId: string): Promise<string>;
+    fetchMessages(threadId: string, options?: FetchOptions): Promise<FetchResult<unknown>>;
+    /**
+     * Fetch messages in forward direction (oldest first, efficient).
+     * Uses native Slack cursor pagination.
+     */
+    private fetchMessagesForward;
+    /**
+     * Fetch messages in backward direction (most recent first).
+     *
+     * Slack's API returns oldest-first, so for backward direction we:
+     * 1. Use `latest` parameter to fetch messages before a timestamp (cursor)
+     * 2. Fetch up to 1000 messages (API limit) and take the last N
+     * 3. Return messages in chronological order (oldest first within the page)
+     *
+     * 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;
+    fetchThread(threadId: string): Promise<ThreadInfo>;
+    /**
+     * Fetch a single message by ID (timestamp).
+     */
+    fetchMessage(threadId: string, messageId: string): Promise<Message<unknown> | null>;
+    encodeThreadId(platformData: SlackThreadId): string;
+    /**
+     * Check if a thread is a direct message conversation.
+     * Slack DM channel IDs start with 'D'.
+     */
+    isDM(threadId: string): boolean;
+    /**
+     * Get the visibility scope of a channel containing the thread.
+     *
+     * - `external`: Slack Connect channel shared with external organizations
+     * - `private`: Private channel (starts with G) or DM (starts with D)
+     * - `workspace`: Public channel visible to all workspace members
+     * - `unknown`: Visibility cannot be determined (not yet cached)
+     */
+    getChannelVisibility(threadId: string): ChannelVisibility;
+    decodeThreadId(threadId: string): SlackThreadId;
+    parseMessage(raw: SlackEvent): Message<unknown>;
+    /**
+     * Synchronous message parsing without user lookup.
+     * Used for parseMessage interface - falls back to user ID for username.
+     */
+    private parseSlackMessageSync;
+    /**
+     * Derive channel ID from a Slack thread ID.
+     * Slack thread IDs are "slack:CHANNEL:THREAD_TS", channel ID is "slack:CHANNEL".
+     */
+    channelIdFromThreadId(threadId: string): string;
+    /**
+     * Fetch channel-level messages (conversations.history, not thread replies).
+     */
+    fetchChannelMessages(channelId: string, options?: FetchOptions): Promise<FetchResult<unknown>>;
+    private fetchChannelMessagesForward;
+    private fetchChannelMessagesBackward;
+    /**
+     * List threads in a Slack channel.
+     * Fetches channel history and filters for messages with replies.
+     */
+    listThreads(channelId: string, options?: ListThreadsOptions): Promise<ListThreadsResult<unknown>>;
+    /**
+     * Fetch Slack channel info/metadata.
+     */
+    fetchChannelInfo(channelId: string): Promise<ChannelInfo>;
+    /**
+     * Post a top-level message to a channel (not in a thread).
+     */
+    postChannelMessage(channelId: string, message: AdapterPostableMessage): Promise<RawMessage<unknown>>;
+    renderFormatted(content: FormattedContent): string;
+    /**
+     * Check if a Slack event is from this bot.
+     *
+     * Slack messages can come from:
+     * - User messages: have `user` field (U_xxx format)
+     * - Bot messages: have `bot_id` field (B_xxx format)
+     *
+     * We check both because:
+     * - _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;
+    /**
+     * Encode response_url and userId into messageId for ephemeral messages.
+     * This allows edit/delete operations to work via response_url.
+     */
+    private encodeEphemeralMessageId;
+    /**
+     * Decode ephemeral messageId to extract messageTs, responseUrl, and userId.
+     * Returns null if the messageId is not an ephemeral encoding.
+     */
+    private decodeEphemeralMessageId;
+    /**
+     * Send a request to Slack's response_url to modify an ephemeral message.
+     */
+    private sendToResponseUrl;
 }
+declare function createSlackAdapter(config?: Partial<SlackAdapterConfig>): SlackAdapter;
 
-export declare function createSlackAdapter(config?: Partial<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 };