eve 0.63.0 → 0.64.0

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

@@ -1,8 +1,10 @@
 import { AsyncLocalStorage } from 'node:async_hooks';
+import { AttachmentTransport } from './_chat-adapter-shared.js';
+export { AttachmentTransport, EncryptedTokenData, decodeKey } from './_chat-adapter-shared.js';
 import { WebClientOptions, WebClient } from './_slack-web-api.js';
-import { Message, AppContextEntity, BaseFormatConverter, Root, AdapterPostableMessage, CardElement, Logger, Adapter, ChatInstance, UserInfo, WebhookOptions, OptionsLoadResult, ModalResponse, ModalElement, LinkPreview, Attachment, RawMessage, EphemeralMessage, ScheduledMessage, FileUpload, PlanModel, PlanContent, EmojiValue, StreamChunk, StreamOptions, FetchOptions, FetchResult, ThreadInfo, ChannelVisibility, ListThreadsOptions, ListThreadsResult, ChannelInfo, FormattedContent } from '#compiled/chat/index.js';
+import { Message, AppContextEntity, CardElement, BaseFormatConverter, Root, AdapterPostableMessage, Logger, Adapter, ChatInstance, UserInfo, WebhookOptions, OptionsLoadResult, ModalResponse, ModalElement, AgentSessionStatus, LinkPreview, Attachment, RawMessage, EphemeralMessage, ScheduledMessage, FileUpload, PlanModel, PlanContent, EmojiValue, TypingOptions, StreamChunk, StreamOptions, FetchOptions, FetchResult, ThreadInfo, ChannelVisibility, FormattedContent, ListThreadsOptions, ListThreadsResult, ChannelInfo } from '#compiled/chat/index.js';
+import { S as SlackFetch } from './fetch-QqNM_Ef3.js';
 import { S as SlackWebhookVerifier } from './types-CdGmMyOr.js';
-export { EncryptedTokenData, decodeKey } from './_chat-adapter-shared.js';
 
 /** A single entity in a Slack active-view context (wire shape). */
 interface SlackAppContextEntity {
@@ -38,6 +40,28 @@ declare function normalizeAppContextEntities(context: SlackAppContext | undefine
  */
 declare function getAppContext(message: Message): AppContextEntity[];
 
+/**
+ * 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.
  *
@@ -90,28 +114,6 @@ 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.
@@ -157,6 +159,10 @@ type SlackBotToken = string | (() => string | Promise<string>);
 interface SlackInstallation {
     botToken: string;
     botUserId?: string;
+    /** Enterprise Grid org ID, when the workspace belongs to (or the app is installed org-wide on) a Grid org */
+    enterpriseId?: string;
+    /** True when this is an Enterprise Grid org-wide installation (stored under the enterprise ID) */
+    isEnterpriseInstall?: boolean;
     teamName?: string;
 }
 /** Options for the feedback buttons appended to streamed replies. */
@@ -197,7 +203,7 @@ interface SlackSuggestedPromptsContext {
     enterpriseId?: string;
     /** Active-view context entities (agent_view, when Slack folds context in). */
     entities?: AppContextEntity[];
-    /** Team the user opened the thread from (legacy assistant_view). */
+    /** Team the user opened the conversation from. */
     teamId?: string;
     /** Assistant thread root (legacy assistant_view; absent under agent_view). */
     threadTs?: string;
@@ -210,6 +216,19 @@ interface SlackSuggestedPromptsContext {
  * resolver to skip setting prompts for that thread.
  */
 type SlackSuggestedPrompts = SlackSuggestedPromptsOptions | ((context: SlackSuggestedPromptsContext) => SlackSuggestedPromptsOptions | null | undefined | Promise<SlackSuggestedPromptsOptions | null | undefined>);
+/** Context passed to a dynamic agent-session title resolver. */
+interface SlackSessionTitleContext {
+    channelId: string;
+    text: string;
+    threadTs: string;
+    userId: string;
+}
+/**
+ * Automatic agent-session title configuration. `true` uses the first line of
+ * the root message, `false` disables automatic titles, and a resolver can
+ * provide a custom title or return null to skip it.
+ */
+type SlackSessionTitle = boolean | ((context: SlackSessionTitleContext) => string | null | Promise<string | null>);
 interface SlackAdapterConfig {
     /**
      * Enable Slack's Agent messaging experience (`agent_view` manifest mode).
@@ -248,6 +267,24 @@ interface SlackAdapterConfig {
      * when a stream falls back to post-and-edit.
      */
     feedbackButtons?: boolean | SlackFeedbackButtonsOptions;
+    /**
+     * Fetch implementation for response_url requests and Socket Mode webhook
+     * forwarding. Defaults to globalThis.fetch at request time. Does not affect
+     * Web API clients, Socket Mode connections, files, or standalone /api helpers.
+     */
+    fetch?: SlackFetch;
+    /**
+     * Transport for lazy and rehydrated file downloads. Replaces the default
+     * DNS-pinned HTTPS transport, which is the only place resolved addresses
+     * are checked against the private-range blocklist, so the transport or
+     * egress proxy must reject internal destination addresses and DNS
+     * rebinding. Return the raw response without following redirects, and
+     * honor the supplied AbortSignal. The downloader still validates URLs,
+     * limits redirects, scopes credentials, destroys the response at the
+     * deadline, and caps the body size. Subclass createFileTransport()
+     * overrides take precedence.
+     */
+    fileTransport?: AttachmentTransport;
     /**
      * Prefix for the state key used to store workspace installations.
      * Defaults to `slack:installation`. The full key will be `{prefix}:{teamId}`.
@@ -282,10 +319,22 @@ interface SlackAdapterConfig {
      * the workspace rejects the first native call.
      */
     nativeStreaming?: boolean;
+    /**
+     * Automatically title new agent sessions from their root user message.
+     * Defaults to true when `agentView` is enabled. Pass false to disable or a
+     * resolver to customize the title.
+     */
+    sessionTitle?: SlackSessionTitle;
     /** 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;
+    /**
+     * Maximum lifetime of one native Slack stream segment before the adapter
+     * finalizes it and continues in a new segment. Defaults to 240 seconds,
+     * safely below Slack's roughly five-minute stream expiry.
+     */
+    streamSegmentMaxAgeMs?: number;
     /**
      * Suggested prompts to pin automatically when an assistant/agent thread
      * opens. Applied on `assistant_thread_started` (legacy `assistant_view`)
@@ -318,7 +367,12 @@ interface SlackAdapterConfig {
      * });
      * ```
      *
-     * Use `apiUrl` to override the Slack Web API base URL.
+     * `agent` also configures Socket Mode, both its HTTP calls and its
+     * WebSocket. `tls` and `apiUrl` reach only Socket Mode's HTTP calls; the
+     * SDK opens the WebSocket with the agent alone, so a custom CA or other
+     * TLS settings for that connection belong on the agent. None of these
+     * configure `fetch` or `fileTransport`. Other options apply only to Web
+     * API clients. Use `apiUrl` to override the Slack Web API base URL.
      */
     webClientOptions?: Omit<WebClientOptions, "slackApiUrl">;
     /**
@@ -354,6 +408,8 @@ declare function buildFeedbackButtonsBlock(options?: SlackFeedbackButtonsOptions
 interface SlackForwardedSocketEvent {
     body: Record<string, unknown>;
     eventType: string;
+    /** Slack redelivery count for the original socket delivery, used for event dedup */
+    retryNum?: number;
     timestamp: number;
     type: "socket_event";
 }
@@ -366,14 +422,69 @@ interface SlackThreadId {
     channel: string;
     threadTs: string;
 }
+/**
+ * Block inside a Slack message event (`event.blocks` or `attachment.blocks`).
+ * Extends the open Block Kit shape with the fields the parser reads directly;
+ * everything else stays reachable through the index signature.
+ */
+interface SlackMessageBlock extends SlackBlock {
+    elements?: SlackMessageBlock[];
+    rows?: unknown;
+    /** `{ code: true }` marks an inline-code text element. */
+    style?: {
+        code?: boolean;
+    };
+    text?: string;
+    url?: string;
+    user_id?: string;
+}
+/** Table extracted from a Slack table block, one mrkdwn string per cell. */
+interface SlackTableData {
+    /**
+     * True when the source rows carry no header styling. GFM tables always
+     * render their first row as a header, so headerless tables get an empty
+     * header row prepended instead of promoting the first data row.
+     */
+    headerless: boolean;
+    rows: string[][];
+}
+/**
+ * One piece of attachment text. `mrkdwn` parts go through the format
+ * converter (formatting characters are markup); `literal` parts render as
+ * plain text where only Slack control sequences (`<@U…>`, `<url|label>`,
+ * entity escapes) are honored, so literal `*`/`_`/backticks survive.
+ */
+type SlackAttachmentPart = {
+    literal: string;
+} | {
+    mrkdwn: string;
+};
+/** Renderable content of one attachment. */
+interface SlackAttachmentContent {
+    /** Structured content. When present, Slack renders only the blocks. */
+    blocks: SlackMessageBlock[];
+    parts: SlackAttachmentPart[];
+    tables: SlackTableData[];
+}
 /** Slack event payload (raw message format) */
 interface SlackEvent {
     /** Legacy attachments (unfurl previews, app unfurls, etc.) */
     attachments?: Array<{
+        blocks?: SlackMessageBlock[];
+        fallback?: string;
+        fields?: Array<{
+            title?: string;
+            value?: string;
+            short?: boolean;
+        }>;
         from_url?: string;
         image_url?: string;
+        is_app_unfurl?: boolean;
         is_msg_unfurl?: boolean;
+        /** Field names Slack renders as mrkdwn ("pretext", "text", "fields") */
+        mrkdwn_in?: string[];
         original_url?: string;
+        pretext?: string;
         service_icon?: string;
         service_name?: string;
         text?: string;
@@ -382,24 +493,20 @@ interface SlackEvent {
         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;
-            }>;
-        }>;
-    }>;
+    blocks?: SlackMessageBlock[];
     bot_id?: string;
+    bot_profile?: {
+        user_id?: string;
+    };
     channel?: string;
     /** Channel type: "channel", "group", "mpim", or "im" (DM) */
     channel_type?: string;
+    /** Deleted message timestamp on message_deleted events */
+    deleted_ts?: string;
     edited?: {
         ts: string;
     };
+    event_ts?: string;
     files?: Array<{
         id?: string;
         mimetype?: string;
@@ -415,6 +522,8 @@ interface SlackEvent {
     latest_reply?: string;
     /** Inner message on message_changed events */
     message?: SlackEvent;
+    /** Previous message snapshot on message_deleted events */
+    previous_message?: SlackEvent;
     /** Number of replies in the thread (present on thread parent messages) */
     reply_count?: number;
     subtype?: string;
@@ -474,6 +583,24 @@ interface SlackAssistantContextChangedEvent {
     event_ts: string;
     type: "assistant_thread_context_changed";
 }
+interface SlackAgentSessionStoppedEvent {
+    channel: string;
+    event_ts: string;
+    streaming_message_ts: string[];
+    thread_ts: string;
+    type: "agent_session_stopped";
+    user: string;
+}
+interface SlackAgentSessionTitleChangedEvent {
+    channel: string;
+    event_ts: string;
+    previous_title?: string;
+    team_id: string;
+    thread_ts: string;
+    title: string;
+    type: "agent_session_title_changed";
+    user: string;
+}
 /** Slack app_home_opened event payload */
 interface SlackAppHomeOpenedEvent {
     channel: string;
@@ -509,7 +636,24 @@ interface SlackUserChangeEvent {
 }
 /** Slack webhook payload envelope */
 interface SlackWebhookPayload {
+    /**
+     * Installation the event is delivered for (truncated to one entry).
+     * Slack documents this — not the top-level fields — as the authoritative
+     * location of is_enterprise_install/enterprise_id on event envelopes.
+     */
+    authorizations?: Array<{
+        enterprise_id?: string | null;
+        team_id?: string | null;
+        is_enterprise_install?: boolean;
+    }>;
     challenge?: string;
+    /**
+     * Workspace the event is contextualized to. Delivered at the envelope top
+     * level (not inside `event`); set on Slack Connect events hosted on an
+     * "away" workspace so calls to the originating channel can echo it back as
+     * `client_context_team_id`.
+     */
+    context_team_id?: string;
     /** Enterprise ID for Enterprise Grid org-wide installs */
     enterprise_id?: string;
     event?: SlackEvent | SlackReactionEvent | SlackAssistantThreadStartedEvent | SlackAssistantContextChangedEvent | SlackAppHomeOpenedEvent | SlackMemberJoinedChannelEvent | SlackUserChangeEvent;
@@ -573,6 +717,7 @@ interface SlackViewSubmissionPayload {
         state: {
             values: Record<string, Record<string, {
                 value?: string;
+                selected_date?: string;
                 selected_option?: {
                     value: string;
                 };
@@ -619,10 +764,13 @@ interface CachedUser {
 declare class SlackAdapter implements Adapter<SlackThreadId, unknown> {
     readonly name = "slack";
     readonly userName: string;
+    readonly supportsTurnCancellation: boolean;
     protected readonly _client: WebClient;
     protected readonly tokenClientCache: Map<string, WebClient>;
     protected readonly slackApiUrl: string | undefined;
     protected readonly webClientOptions: SlackAdapterConfig["webClientOptions"];
+    protected readonly fetch: SlackFetch;
+    protected readonly configuredFileTransport: AttachmentTransport | undefined;
     protected readonly signingSecret: string | undefined;
     protected readonly webhookVerifier: ((request: Request, body: string) => unknown | Promise<unknown>) | undefined;
     protected readonly defaultBotTokenProvider: (() => string | Promise<string>) | undefined;
@@ -634,6 +782,8 @@ declare class SlackAdapter implements Adapter<SlackThreadId, unknown> {
     protected static readonly USER_CACHE_TTL_MS: number;
     protected static readonly CHANNEL_CACHE_TTL_MS: number;
     protected static readonly REVERSE_INDEX_TTL_MS: number;
+    /** How long delivered event IDs are remembered for retry deduplication. Slack retries at ~1 min and ~5 min, and the opt-in Delayed Events feature redelivers hourly for up to 24 hours. */
+    protected static readonly EVENT_DEDUPE_TTL_MS: number;
     /**
      * Cache of channel IDs known to be external/shared (Slack Connect).
      * Populated from `is_ext_shared_channel` in incoming webhook payloads.
@@ -641,11 +791,13 @@ declare class SlackAdapter implements Adapter<SlackThreadId, unknown> {
     private readonly _externalChannels;
     protected readonly appToken: string | undefined;
     protected readonly agentView: boolean;
+    protected readonly sessionTitle: SlackSessionTitle;
     protected readonly suggestedPrompts?: SlackSuggestedPrompts;
     protected readonly loadingMessages?: string[];
     /** Normalized feedbackButtons config (`true` becomes `{}`). */
     protected readonly feedbackButtons?: SlackFeedbackButtonsOptions;
     protected readonly nativeStreaming: boolean;
+    protected readonly streamSegmentMaxAgeMs: number;
     /**
      * Latched when the workspace rejects native streaming with an error that
      * won't heal (e.g. `unknown_method` on GovSlack) so later streams skip the
@@ -666,6 +818,14 @@ declare class SlackAdapter implements Adapter<SlackThreadId, unknown> {
         isExtSharedChannel?: boolean;
         enterpriseId?: string;
         isEnterpriseInstall?: boolean;
+        /** team_id (or enterprise_id for org-wide installs) the current request resolved its token from */
+        installationId?: string;
+        /** Workspace the current event occurred in — required as an explicit team_id on workspace-scoped API calls when using an org-wide token */
+        teamId?: string;
+        /** context_team_id from the incoming event, echoed back as client_context_team_id on channel-addressed calls (away-hosted shared channels) */
+        contextTeamId?: string;
+        /** Channel the context_team_id came from — the echo only applies to calls targeting that channel */
+        contextChannel?: string;
     }>;
     /** Bot user ID (e.g., U_BOT_123) used for mention detection */
     get botUserId(): string | undefined;
@@ -718,6 +878,17 @@ declare class SlackAdapter implements Adapter<SlackThreadId, unknown> {
     /**
      * Add the current token to API call options.
      * Workaround for Slack WebClient types not including `token` in per-method args.
+     *
+     * For Enterprise Grid org-wide installs the token spans every workspace in
+     * the org, so workspace-scoped Web API methods (conversations.list,
+     * users.list, usergroups.*, …) require an explicit `team_id`. Slack
+     * documents always passing it as safe — the field is ignored on
+     * workspace-level tokens and on methods that don't take it.
+     *
+     * When the incoming event carried a `context_team_id` (shared channels
+     * hosted on an "away" workspace), it is echoed back as
+     * `client_context_team_id` on channel-addressed calls, per Slack's
+     * Enterprise Grid guidance.
      */
     protected withToken<T extends Record<string, any>>(options: T): Promise<T & {
         token: string;
@@ -737,9 +908,17 @@ declare class SlackAdapter implements Adapter<SlackThreadId, unknown> {
      * Handle the Slack OAuth V2 callback.
      * Accepts the incoming request, extracts the authorization code,
      * exchanges it for tokens, and saves the installation.
+     *
+     * For Enterprise Grid org-wide installs (`is_enterprise_install`), Slack
+     * returns `team: null` and the installation is keyed by the enterprise ID
+     * instead — the returned `teamId` is always the storage key, so it can be
+     * passed back to `getInstallation` / `deleteInstallation` for both install
+     * types.
      */
     handleOAuthCallback(request: Request, options?: SlackOAuthCallbackOptions): Promise<{
         teamId: string;
+        enterpriseId?: string;
+        isEnterpriseInstall: boolean;
         installation: SlackInstallation;
     }>;
     /**
@@ -749,8 +928,18 @@ declare class SlackAdapter implements Adapter<SlackThreadId, unknown> {
     /**
      * 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;
+     *
+     * In multi-workspace deployments, pass `installationId` (the `team_id`, or
+     * `enterprise_id` for org-wide installs — the same key the installation was
+     * stored under) so per-user caches (profile cache and display-name mention
+     * index) are scoped to that installation. Without it these fall back to the
+     * unscoped global key, which can bleed one tenant's cached profiles and
+     * mention resolution into another when the same process posts for multiple
+     * workspaces.
+     */
+    withBotToken<T>(token: string, fn: () => T, options?: {
+        installationId?: string;
+    }): T;
     /**
      * 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
@@ -768,7 +957,49 @@ declare class SlackAdapter implements Adapter<SlackThreadId, unknown> {
         installationId: string;
         isEnterpriseInstall: boolean;
         enterpriseId?: string;
+        teamId?: string;
     } | null;
+    /**
+     * Extract installation info from an already-parsed interactive payload
+     * (socket mode delivers these as objects rather than form-urlencoded).
+     */
+    protected extractInstallationFromInteractivePayload(payload: Record<string, unknown>): {
+        installationId: string;
+        isEnterpriseInstall: boolean;
+        enterpriseId?: string;
+        teamId?: string;
+    } | null;
+    /**
+     * Resolve the multi-workspace request context for an event_callback
+     * payload. Shared by the HTTP webhook path and the socket-mode path so
+     * both resolve per-installation tokens the same way.
+     *
+     * Returns:
+     * - the resolved context to run the event under,
+     * - `"not-applicable"` when no resolution is needed (single-workspace
+     *   mode, or the payload carries no installation ID) — process without
+     *   a request context,
+     * - `"unresolved"` when an installation ID was present but no
+     *   installation was found — drop the event.
+     */
+    protected resolveEventRequestContext(payload: SlackWebhookPayload): Promise<{
+        token: string;
+        botUserId?: string;
+        enterpriseId?: string;
+        isEnterpriseInstall: boolean;
+        installationId: string;
+        teamId?: string;
+        contextTeamId?: string;
+        contextChannel?: string;
+    } | "not-applicable" | "unresolved">;
+    /**
+     * Scope prefix for installation-owned cache keys. In multi-workspace
+     * deployments user profiles, display-name indexes, and channel names must
+     * not be shared across installations. Single-workspace mode (and code
+     * running outside a webhook context) uses the unscoped key.
+     */
+    protected installationCacheScope(): string;
+    protected unfurlCacheKey(channelId: string, messageTs: string): string;
     /**
      * Look up user info from Slack API with caching via state adapter.
      * Returns null when the API call fails.
@@ -781,6 +1012,25 @@ declare class SlackAdapter implements Adapter<SlackThreadId, unknown> {
     protected lookupChannel(channelId: string): Promise<string>;
     getUser(userId: string): Promise<UserInfo | null>;
     handleWebhook(request: Request, options?: WebhookOptions): Promise<Response>;
+    /**
+     * Handle a slash command, resolving the per-installation token first in
+     * multi-workspace mode. Shared by the HTTP webhook and socket-mode paths.
+     */
+    protected runSlashCommand(params: URLSearchParams, options?: WebhookOptions): Promise<Response>;
+    /**
+     * Record that an event delivery was dispatched, so redeliveries
+     * (`x-slack-retry-num` / socket `retry_num`) can be dropped. Fire-and-forget:
+     * a failed write only means a retry gets reprocessed, which downstream
+     * message dedup already tolerates.
+     */
+    protected markEventDelivered(payload: SlackWebhookPayload): void;
+    /**
+     * Check whether a retried event delivery was already dispatched. Only
+     * consulted on retries (retryNum > 0), so first deliveries pay no state
+     * read. Events missed entirely (never dispatched, e.g. delivered while
+     * disconnected) have no marker and are still recovered via the retry.
+     */
+    protected isDuplicateEventDelivery(payload: SlackWebhookPayload, retryNum?: number): Promise<boolean>;
     /** Extract and dispatch events from a validated payload */
     protected processEventPayload(payload: SlackWebhookPayload, options?: WebhookOptions): void;
     /**
@@ -808,6 +1058,15 @@ declare class SlackAdapter implements Adapter<SlackThreadId, unknown> {
     protected handleViewClosed(payload: SlackViewClosedPayload, options?: WebhookOptions): void;
     protected modalResponseToSlack(response: ModalResponse, contextId?: string): SlackModalResponse;
     protected convertModalJSX(modal: ModalElement): ModalElement;
+    /**
+     * Transport-shaped WebClient options for Socket Mode. SocketModeClient
+     * Object.assigns clientOptions over its own app-token headers and mutates
+     * the object to install retry defaults, so headers and retryConfig are not
+     * forwarded and every call returns a fresh object.
+     */
+    private socketTransportOptions;
+    /** POSTs a JSON body through the configured fetch. */
+    private postJson;
     /**
      * Start Socket Mode connection.
      * Creates a SocketModeClient, registers event handlers, and connects.
@@ -816,7 +1075,7 @@ declare class SlackAdapter implements Adapter<SlackThreadId, unknown> {
     /**
      * Route a socket mode event to the appropriate handler.
      */
-    protected routeSocketEvent(body: Record<string, unknown>, eventType: string, ack: (response?: Record<string, unknown>) => Promise<void>, options?: WebhookOptions): Promise<void>;
+    protected routeSocketEvent(body: Record<string, unknown>, eventType: string, ack: (response?: Record<string, unknown>) => Promise<void>, options?: WebhookOptions, retryNum?: number): Promise<void>;
     /**
      * Start a transient Socket Mode listener for serverless environments.
      * The listener maintains a WebSocket for `durationMs`, acks events, and
@@ -846,7 +1105,8 @@ declare class SlackAdapter implements Adapter<SlackThreadId, unknown> {
      * Bot message filtering (isMe) is handled centrally by the Chat class.
      */
     protected handleMessageEvent(event: SlackEvent, options?: WebhookOptions): void;
-    protected handleMessageChanged(event: SlackEvent, _options?: WebhookOptions): void;
+    protected handleMessageChanged(event: SlackEvent, options?: WebhookOptions): void;
+    protected handleMessageDeleted(event: SlackEvent, options?: WebhookOptions): void;
     /**
      * Handle reaction events from Slack (reaction_added, reaction_removed).
      */
@@ -861,11 +1121,13 @@ declare class SlackAdapter implements Adapter<SlackThreadId, unknown> {
      * Fires when a user navigates to a different channel with the assistant panel open.
      */
     protected handleAssistantContextChanged(event: SlackAssistantContextChangedEvent, options?: WebhookOptions): void;
+    protected handleAgentSessionStopped(event: SlackAgentSessionStoppedEvent, options?: WebhookOptions): void;
+    protected handleAgentSessionTitleChanged(event: SlackAgentSessionTitleChangedEvent, options?: WebhookOptions): void;
     /**
      * Handle app_home_opened events from Slack.
      * Fires when a user opens the bot's Home tab.
      */
-    protected handleAppHomeOpened(event: SlackAppHomeOpenedEvent, options?: WebhookOptions): void;
+    protected handleAppHomeOpened(event: SlackAppHomeOpenedEvent, options?: WebhookOptions, teamId?: string): void;
     /**
      * Handle app_context_changed events (Slack Agent messaging experience).
      * Reports the user's current active view via normalized entities.
@@ -898,32 +1160,45 @@ declare class SlackAdapter implements Adapter<SlackThreadId, unknown> {
      * the webhook path where a failure must not turn into a 500.
      */
     protected applyConfiguredSuggestedPrompts(context: SlackSuggestedPromptsContext): Promise<void>;
+    protected applyConfiguredSessionTitle(event: SlackEvent): Promise<void>;
     /**
      * Set status/thinking indicator for an assistant thread.
-     * Slack Assistants API: assistant.threads.setStatus
+     * Uses Agent Sessions when `agentView` is enabled and the legacy Assistants
+     * API otherwise.
+     *
+     * A custom status is surfaced through the legacy Assistants API: its
+     * compatibility bridge renders the text in the agent-session loading UX.
+     * An empty status clears the loading state via the Agent Sessions
+     * lifecycle.
      *
      * When `loadingMessages` is omitted, falls back to the adapter-level
      * `loadingMessages` config.
      */
     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
+     * Set a Slack Agent Session lifecycle state, creating the session if needed.
+     */
+    setSessionStatus(channelId: string, threadTs: string, status: AgentSessionStatus, options?: {
+        initiatorUserId?: string;
+        title?: string;
+    }): Promise<void>;
+    protected renameAgentSession(channelId: string, threadTs: string, title: string): Promise<void>;
+    /**
+     * Set title for an assistant thread or agent session.
      */
     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.
+     * renders them as @displayName instead of @U123. The bot's own mention is
+     * decoded too: `detectSelfMention` classifies it from the event's blocks
+     * (or, without blocks, this text) before the id markup is replaced.
+     */
+    protected resolveInlineMentions(text: string): Promise<string>;
+    /**
+     * Look up display names for collected mention IDs in one parallel wave.
      */
-    protected resolveInlineMentions(text: string, skipSelfMention: boolean): Promise<string>;
+    private lookupMentionNames;
     /**
      * Extract link URLs from a Slack event.
      * Uses the `blocks` field (rich_text blocks with link elements) when available,
@@ -935,10 +1210,27 @@ declare class SlackAdapter implements Adapter<SlackThreadId, unknown> {
      * includes a `fetchMessage` callback that fetches and parses the linked message.
      */
     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[]>;
+    /**
+     * Whether the message invokes the bot.
+     *
+     * Slack fires `app_mention` for a bot id that only appears inside code, so the
+     * invocation is classified from the message content: a `user` element for the
+     * bot outside code, or a `<@U…>` token outside code in mrkdwn content, is a
+     * mention. Inline (`style.code`) and preformatted content renders literally,
+     * so a bot id there is not.
+     *
+     * Returns `true` for an invocation and `false` when the content refers to
+     * the bot only literally, or not at all on an ordinary message. An
+     * `app_mention` whose content never shows the known bot id is still trusted:
+     * Slack saw a mention under an id the adapter does not know, such as the
+     * `W…` form an Enterprise Grid workspace emits for a `U…` bot. Without any
+     * bot id, `app_mention` is trusted the same way and other messages stay
+     * undetermined for the SDK's text-based fallback.
+     */
+    protected detectSelfMention(event: SlackEvent, rawText: string, attachments: SlackAttachmentContent[]): boolean | undefined;
+    protected parseSlackMessage(event: SlackEvent, threadId: string): Promise<Message<unknown>>;
+    protected parseSlackTimestamp(ts: string | undefined): Date | undefined;
+    protected enrichLinks(links: LinkPreview[], channelId?: string, messageTs?: string): Promise<LinkPreview[]>;
     /**
      * Create an Attachment object from a Slack file.
      * Includes a fetchData method that uses the bot token for auth.
@@ -952,7 +1244,12 @@ declare class SlackAdapter implements Adapter<SlackThreadId, unknown> {
         original_w?: number;
         original_h?: number;
     }, teamId?: string): Attachment;
-    protected fetchSlackFile(url: string, token: string): Promise<Buffer>;
+    protected fetchSlackFile(url: string, token: SlackBotToken): Promise<Buffer>;
+    /**
+     * Transport used for guarded file downloads. Subclasses can return a
+     * custom AttachmentTransport, overriding the configured fileTransport.
+     */
+    protected createFileTransport(): AttachmentTransport | undefined;
     rehydrateAttachment(attachment: Attachment): Attachment;
     /**
      * Resolve @name mentions in text to Slack <@USER_ID> format using the
@@ -1005,7 +1302,8 @@ declare class SlackAdapter implements Adapter<SlackThreadId, unknown> {
      * @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>;
+    startTyping(threadId: string, status?: string, options?: TypingOptions): Promise<void>;
+    endTyping(threadId: string, status?: AgentSessionStatus): Promise<void>;
     /**
      * Stream a message using Slack's native streaming API.
      *
@@ -1017,6 +1315,11 @@ declare class SlackAdapter implements Adapter<SlackThreadId, unknown> {
      * streaming API as chunk payloads, enabling native task progress cards
      * and plan displays in the Slack AI Assistant UI.
      *
+     * Slack expires a native stream after roughly five minutes, so a reply
+     * that streams longer than `streamSegmentMaxAgeMs` is finalized and
+     * continued in a new message. The returned `id` is the last message of
+     * the reply; earlier segments are already final and are not tracked.
+     *
      * Falls back to post-and-edit when the thread lacks native stream context.
      */
     stream(threadId: string, textStream: AsyncIterable<string | StreamChunk>, options?: StreamOptions): Promise<RawMessage<unknown> | null>;
@@ -1049,6 +1352,25 @@ declare class SlackAdapter implements Adapter<SlackThreadId, unknown> {
      */
     fetchMessage(threadId: string, messageId: string): Promise<Message<unknown> | null>;
     encodeThreadId(platformData: SlackThreadId): string;
+    /**
+     * Thread ID for a message-shaped event. Single source of truth for how
+     * message, edit, and delete events map onto a thread: they must agree, or
+     * an edit dispatches to a different thread than the message it edits.
+     *
+     * For DMs under assistant_view (legacy): top-level messages use empty
+     * threadTs (matches openDM subscriptions); thread replies use thread_ts for
+     * per-conversation isolation.
+     * Under agent_view the Messages-tab conversation is threaded per Slack's
+     * model, each user message being a thread root, so reply in-thread using
+     * `thread_ts ?? ts`.
+     * For channels: always use thread_ts or ts for per-thread IDs.
+     */
+    protected threadIdForMessageEvent(event: {
+        channel?: string;
+        channel_type?: string;
+        thread_ts?: string;
+        ts?: string;
+    }): string;
     /**
      * Check if a thread is a direct message conversation.
      * Slack DM channel IDs start with 'D'.
@@ -1070,6 +1392,31 @@ declare class SlackAdapter implements Adapter<SlackThreadId, unknown> {
      * Used for parseMessage interface - falls back to user ID for username.
      */
     protected parseSlackMessageSync(event: SlackEvent, threadId: string): Message<unknown>;
+    protected content(event: SlackEvent, text: string, attachments?: SlackAttachmentContent[]): FormattedContent;
+    /**
+     * Like `content`, but resolves user and channel mentions inside table
+     * cells and attachment content the same way `resolveInlineMentions`
+     * resolves them in body text. All mention IDs are collected up front and
+     * looked up in a single parallel wave so no ID is fetched twice.
+     */
+    protected resolvedContent(event: SlackEvent, text: string, attachments?: SlackAttachmentContent[]): Promise<FormattedContent>;
+    private assembleContent;
+    /**
+     * Render one attachment's content to block nodes. Literal lines share a
+     * paragraph (separated by hard breaks) so an attachment reads as one block;
+     * mrkdwn parts are parsed in isolation so an unclosed code fence in the
+     * message body or another attachment can't swallow this one's content.
+     * Tables from the attachment's blocks follow its text, keeping each
+     * attachment's content adjacent.
+     */
+    private attachmentNodes;
+    private tableNode;
+    /**
+     * Convert a cell's mrkdwn text to table cell (phrasing) content via the
+     * same format converter used for body text, so mentions, links, and emoji
+     * render consistently.
+     */
+    private cellChildren;
     /**
      * Derive channel ID from a Slack thread ID.
      * Slack thread IDs are "slack:CHANNEL:THREAD_TS", channel ID is "slack:CHANNEL".
@@ -1100,10 +1447,10 @@ declare class SlackAdapter implements Adapter<SlackThreadId, unknown> {
      *
      * Slack messages can come from:
      * - User messages: have `user` field (U_xxx format)
-     * - Bot messages: have `bot_id` field (B_xxx format)
+     * - Bot messages: have `bot_id` and may include a bot user ID
      *
      * We check both because:
-     * - _botUserId is the user ID (U_xxx) - matches event.user
+     * - _botUserId is the user ID (U_xxx) - matches event.user or bot_profile.user_id
      * - _botId is the bot ID (B_xxx) - matches event.bot_id
      */
     protected isMessageFromSelf(event: SlackEvent): boolean;
@@ -1132,4 +1479,4 @@ declare class SlackAdapter implements Adapter<SlackThreadId, unknown> {
 }
 declare function createSlackAdapter(config?: SlackAdapterConfig): SlackAdapter;
 
-export { SlackAdapter, type SlackAdapterConfig, type SlackAdapterMode, type SlackAppContext, type SlackAppContextChangedEvent, type SlackAppContextEntity, type SlackBotToken, type SlackEvent, type SlackFeedbackButtonsOptions, SlackFormatConverter, type SlackInstallation, SlackFormatConverter as SlackMarkdownConverter, type SlackOAuthCallbackOptions, type SlackReactionEvent, type SlackSuggestedPrompt, type SlackSuggestedPrompts, type SlackSuggestedPromptsContext, type SlackSuggestedPromptsOptions, type SlackThreadId, buildFeedbackButtonsBlock, cardToBlockKit, cardToFallbackText, createSlackAdapter, getAppContext, normalizeAppContextEntities };
+export { SlackAdapter, type SlackAdapterConfig, type SlackAdapterMode, type SlackAppContext, type SlackAppContextChangedEvent, type SlackAppContextEntity, type SlackBlock, type SlackBotToken, type SlackEvent, type SlackFeedbackButtonsOptions, SlackFormatConverter, type SlackInstallation, SlackFormatConverter as SlackMarkdownConverter, type SlackMessageBlock, type SlackOAuthCallbackOptions, type SlackReactionEvent, type SlackSessionTitle, type SlackSessionTitleContext, type SlackSuggestedPrompt, type SlackSuggestedPrompts, type SlackSuggestedPromptsContext, type SlackSuggestedPromptsOptions, type SlackThreadId, buildFeedbackButtonsBlock, cardToBlockKit, cardToFallbackText, createSlackAdapter, getAppContext, normalizeAppContextEntities };