eve 0.5.4 → 0.6.0-beta.3

package/dist/src/public/channels/slack/hitl.d.ts

@@ -0,0 +1,141 @@
+/**
+ * Slack HITL widget rendering + click-decode helpers.
+ *
+ * Wire format: select-style HITL widgets mint `action_id =
+ * HITL_ACTION_PREFIX + requestId`. Button widgets add a stable suffix so
+ * every button in the same Slack actions block has a unique `action_id`.
+ * The decoder requires that suffix for button payloads.
+ *
+ * Buttons surface the selected option on `action.value`; radio and
+ * static selects surface it on `selected_option.value`. The decoder
+ * picks whichever is set so the renderer can pick a widget kind on
+ * UX grounds without changing the read path.
+ */
+import type { InputRequest } from "#runtime/input/types.js";
+/**
+ * Wire-format prefix every framework HITL widget mints onto its
+ * `action_id`. Exposed so end-user adapters that render their own
+ * interactive widgets can avoid collisions.
+ */
+export declare const HITL_ACTION_PREFIX = "eve_input:";
+/**
+ * `action_id` prefix for the "Type your answer" button that opens a
+ * freeform-answer modal. Splitting the prefix from {@link HITL_ACTION_PREFIX}
+ * lets the route handler differentiate "this click is a final answer"
+ * (resolve via `inputResponses`) from "this click needs a modal first"
+ * (call `views.open`, then resolve on `view_submission`).
+ */
+export declare const HITL_FREEFORM_ACTION_PREFIX = "eve_input_freeform:";
+/**
+ * `view.callback_id` carried on the freeform-answer modal. Used to
+ * route the inbound `view_submission` back to this channel.
+ */
+export declare const HITL_FREEFORM_MODAL_CALLBACK_ID = "eve_input_freeform_submit";
+/**
+ * `block_id` of the modal's text-input block — the route reads the
+ * submitted text out of `view.state.values[block_id][action_id]`.
+ */
+export declare const HITL_FREEFORM_MODAL_BLOCK_ID = "eve_freeform_block";
+/**
+ * `action_id` of the text input inside the freeform answer modal.
+ */
+export declare const HITL_FREEFORM_MODAL_ACTION_ID = "eve_freeform_text";
+/**
+ * Subset of one Slack interactivity action the HITL decoder reads.
+ * Mirrors the relevant fields of `SlackInteractionAction`.
+ */
+interface SlackHitlAction {
+    readonly actionId: string;
+    /** `value` field on Slack `button` payloads. */
+    readonly value?: string;
+    /** `selected_option.value` field on radio / static-select payloads. */
+    readonly selectedOptionValue?: string;
+}
+/**
+ * Resolved HITL response derived from one Slack interactivity action.
+ * Matches the `InputResponse` contract minus `text` — freeform answers
+ * come back through a different interaction path.
+ */
+interface DerivedHitlResponse {
+    readonly requestId: string;
+    readonly optionId: string;
+}
+/**
+ * Decodes one Slack interactivity action into an HITL response, or
+ * returns `null` when the action does not match an HITL widget the
+ * framework rendered.
+ */
+export declare function deriveHitlResponse(action: SlackHitlAction): DerivedHitlResponse | null;
+/**
+ * Returns `true` when the action id was minted by an HITL widget the
+ * framework rendered. Used by the channel route to split inbound
+ * clicks into the HITL path vs. the user-owned `onInteraction` path.
+ */
+export declare function isHitlAction(actionId: string): boolean;
+/**
+ * Renders one `InputRequest` as Block Kit blocks:
+ *
+ * - `display === "select"` with ≤ {@link RADIO_SELECT_OPTION_LIMIT}
+ *   options → `radio_buttons`. Single-click answer, options stay
+ *   visible.
+ * - `display === "select"` with more options → `static_select`
+ *   dropdown so the picker stays scrollable.
+ * - Anything else with options → buttons. Best for visually distinct
+ *   choices (approve / deny / cancel).
+ * - No options (or `allowFreeform: true`) → a single "Type your answer"
+ *   button that opens a Slack modal with a plain_text_input. The modal
+ *   submission comes back as a `view_submission` webhook the channel
+ *   resolves into an {@link InputResponse} carrying `text`.
+ *
+ * Always emits at least the prompt section.
+ */
+export declare function renderInputRequestBlocks(request: InputRequest): unknown[];
+/**
+ * Metadata round-tripped on the freeform-answer modal's
+ * `private_metadata` field. Threaded from the button click that opens
+ * the modal to the `view_submission` that closes it so the route can
+ * deliver the answer back to the right session.
+ */
+export interface HitlFreeformModalMetadata {
+    readonly continuationToken: string;
+    readonly channelId: string;
+    readonly threadTs: string;
+    readonly messageTs: string;
+    readonly requestId: string;
+}
+/**
+ * Builds the `views.open` payload for the freeform-answer modal. The
+ * triggering `prompt` is preserved as a header section so the user can
+ * re-read what they're answering inside the modal.
+ *
+ * Title is auto-truncated to the Slack modal-title limit.
+ */
+export declare function buildFreeformModalView(input: {
+    readonly metadata: HitlFreeformModalMetadata;
+    readonly prompt?: string;
+}): Record<string, unknown>;
+/**
+ * True when an `action_id` was minted by the framework's freeform-answer
+ * button (the click that opens a modal — not the final answer).
+ */
+export declare function isFreeformAction(actionId: string): boolean;
+/**
+ * Extracts the requestId from a freeform-answer button's `action_id`.
+ */
+export declare function freeformRequestIdFromActionId(actionId: string): string | undefined;
+/**
+ * Renders the "answered" replacement blocks for a previously-posted
+ * HITL card. Preserves the original prompt block (so context stays
+ * visible), appends a confirmation line naming the chosen answer, and
+ * attributes the click to the user when their id is known.
+ *
+ * Slack's `chat.update` replaces every block in one shot, so the caller
+ * passes the full list to `blocks` and the rendered fallback text to
+ * `text`.
+ */
+export declare function buildAnsweredBlocks(input: {
+    readonly promptBlock: unknown;
+    readonly answerLabel: string;
+    readonly userId?: string;
+}): unknown[];
+export {};

package/dist/src/public/channels/slack/hitl.js

@@ -0,0 +1 @@
+import{truncateModalTitle,truncatePlainText,truncateSectionText}from"#public/channels/slack/limits.js";const HITL_ACTION_PREFIX=`eve_input:`,HITL_FREEFORM_ACTION_PREFIX=`eve_input_freeform:`,HITL_FREEFORM_MODAL_CALLBACK_ID=`eve_input_freeform_submit`,HITL_FREEFORM_MODAL_BLOCK_ID=`eve_freeform_block`,HITL_FREEFORM_MODAL_ACTION_ID=`eve_freeform_text`,BUTTON_ACTION_ID_RE=/^(?<requestId>.+):button:\d+$/u;function deriveHitlResponse(e){if(!e.actionId.startsWith(`eve_input:`))return null;let t=e.actionId.slice(10);if(e.selectedOptionValue!==void 0)return t?{optionId:e.selectedOptionValue,requestId:t}:null;if(e.value!==void 0){let n=BUTTON_ACTION_ID_RE.exec(t)?.groups?.requestId;return n?{optionId:e.value,requestId:n}:null}return null}function isHitlAction(e){return e.startsWith(HITL_ACTION_PREFIX)}function renderInputRequestBlocks(e){let t={text:{text:truncateSectionText(e.prompt),type:`mrkdwn`},type:`section`},a=`${HITL_ACTION_PREFIX}${e.requestId}`,o=e.options,s=e.allowFreeform===!0||!o||o.length===0;return o&&o.length>0&&e.display===`select`?[t,{type:`actions`,elements:[o.length<=6?{type:`radio_buttons`,action_id:a,options:o.map(buildOption)}:{type:`static_select`,action_id:a,options:o.map(buildOption),placeholder:{type:`plain_text`,text:`Choose an option`}}]}]:o&&o.length>0?[t,{type:`actions`,elements:o.map((e,t)=>buildButton(e,a,t))}]:s?[t,{type:`actions`,elements:[{type:`button`,action_id:`${HITL_FREEFORM_ACTION_PREFIX}${e.requestId}`,text:{type:`plain_text`,text:`Type your answer`},style:`primary`,value:e.requestId}]}]:[t]}function buildFreeformModalView(t){let r=t.prompt?truncateModalTitle(t.prompt):`Your answer`,i=t.prompt?[{type:`section`,text:{type:`mrkdwn`,text:truncateSectionText(t.prompt)}}]:[];return{type:`modal`,callback_id:HITL_FREEFORM_MODAL_CALLBACK_ID,private_metadata:JSON.stringify(t.metadata),title:{type:`plain_text`,text:r},submit:{type:`plain_text`,text:`Submit`},close:{type:`plain_text`,text:`Cancel`},blocks:[...i,{type:`input`,block_id:HITL_FREEFORM_MODAL_BLOCK_ID,element:{type:`plain_text_input`,action_id:HITL_FREEFORM_MODAL_ACTION_ID,multiline:!0,placeholder:{type:`plain_text`,text:`Type your answer here...`}},label:{type:`plain_text`,text:`Answer`}}]}}function isFreeformAction(e){return e.startsWith(HITL_FREEFORM_ACTION_PREFIX)}function freeformRequestIdFromActionId(e){if(!isFreeformAction(e))return;let t=e.slice(19);return t.length>0?t:void 0}function buildButton(e,n,r){let i={action_id:`${n}:button:${r}`,text:{text:truncatePlainText(e.label),type:`plain_text`},type:`button`,value:e.id};return(e.style===`primary`||e.style===`danger`)&&(i.style=e.style),i}function buildOption(e){let n={text:{text:truncatePlainText(e.label),type:`plain_text`},value:e.id},r=truncatePlainText(e.description);return r&&r.length>0&&(n.description={text:r,type:`plain_text`}),n}function buildAnsweredBlocks(e){let t=[];return e.promptBlock!==void 0&&e.promptBlock!==null&&t.push(e.promptBlock),t.push({type:`section`,text:{type:`mrkdwn`,text:`:white_check_mark: *${e.answerLabel}*`}}),e.userId&&e.userId.length>0&&t.push({type:`context`,elements:[{type:`mrkdwn`,text:`Answered by <@${e.userId}>`}]}),t}export{HITL_ACTION_PREFIX,HITL_FREEFORM_ACTION_PREFIX,HITL_FREEFORM_MODAL_ACTION_ID,HITL_FREEFORM_MODAL_BLOCK_ID,HITL_FREEFORM_MODAL_CALLBACK_ID,buildAnsweredBlocks,buildFreeformModalView,deriveHitlResponse,freeformRequestIdFromActionId,isFreeformAction,isHitlAction,renderInputRequestBlocks};

package/dist/src/public/channels/slack/inbound.d.ts

@@ -0,0 +1,122 @@
+/**
+ * Inbound Slack event → harness shaping.
+ *
+ * The channel calls these helpers on every inbound `app_mention` event
+ * before handing it to the runtime:
+ *
+ * 1. {@link parseAppMentionEvent} parses Slack's webhook envelope into
+ *    a channel-owned {@link SlackMessage}, with the body's text already
+ *    re-rendered as GFM markdown so the agent does not see raw
+ *    `<@U…>` / `<https://…|…>` fragments.
+ * 2. {@link formatSlackContextBlock} renders a `<slack_context>` block
+ *    naming the actor, channel, and thread. The channel delivers it as
+ *    a dedicated context entry so the agent always knows who and where
+ *    it is talking.
+ */
+/**
+ * Author metadata for an inbound Slack message. Channel-owned shape;
+ * does not depend on the chat SDK's `Author` interface.
+ */
+export interface SlackAuthor {
+    readonly userId: string;
+    readonly userName: string | undefined;
+    readonly fullName: string | undefined;
+    readonly isBot: boolean;
+    readonly isMe: boolean;
+}
+/**
+ * Inbound Slack file attachment. The channel reads only `type`, `url`,
+ * `name`, `mimeType`, and `size`. The full Slack file object stays
+ * available on {@link SlackMessage.raw}.
+ */
+export interface SlackAttachment {
+    readonly id: string;
+    readonly type: "image" | "file" | "video" | "audio";
+    readonly url: string | undefined;
+    readonly name: string | undefined;
+    readonly mimeType: string | undefined;
+    readonly size: number | undefined;
+}
+/**
+ * Channel-owned representation of one inbound Slack message.
+ *
+ * Returned by {@link parseAppMentionEvent} for the triggering mention.
+ * Replaces the chat SDK `Message` type in the public callback surface
+ * (e.g. `onAppMention(ctx, message)`).
+ */
+export interface SlackMessage {
+    /** The original Slack text (mrkdwn). */
+    readonly text: string;
+    /** {@link text} re-rendered as GFM markdown for the agent. */
+    readonly markdown: string;
+    /** Slack message ts. */
+    readonly ts: string;
+    /** Thread parent ts (root). Equals {@link ts} for non-thread events. */
+    readonly threadTs: string;
+    /** Slack channel id. */
+    readonly channelId: string;
+    /** Slack team id, when the envelope carried one. */
+    readonly teamId: string | undefined;
+    /** Author of the message. May be `undefined` for system events. */
+    readonly author: SlackAuthor | undefined;
+    /** File / image attachments on the inbound message. */
+    readonly attachments: readonly SlackAttachment[];
+    /** Raw inbound event payload from Slack. */
+    readonly raw: Record<string, unknown>;
+}
+/**
+ * Slack webhook envelope for an `event_callback`. The channel cares
+ * only about `team_id` (for ergonomic auth derivation) and the inner
+ * `event` payload.
+ */
+export interface SlackEventCallback {
+    readonly type: "event_callback";
+    readonly team_id?: string;
+    readonly event?: {
+        readonly type?: string;
+    } & Record<string, unknown>;
+    readonly event_id?: string;
+    readonly event_time?: number;
+    readonly [key: string]: unknown;
+}
+/**
+ * Parses a Slack `app_mention` event into a {@link SlackMessage}.
+ *
+ * Returns `null` when the envelope is not an `app_mention` event or
+ * when required fields (channel id, ts) are missing.
+ */
+export declare function parseAppMentionEvent(envelope: SlackEventCallback): SlackMessage | null;
+/**
+ * Parses a Slack `message` event with `channel_type: "im"` into a
+ * {@link SlackMessage}.
+ *
+ * Returns `null` when:
+ * - the envelope is not an IM `message` event,
+ * - required fields (channel id, ts) are missing,
+ * - the message carries a system `subtype` (edits, deletes, joins, etc.)
+ *   other than `file_share` — file uploads are real user messages and
+ *   must reach the handler with their attachments intact, or
+ * - the message was posted by a bot (`bot_id` set) — this prevents the
+ *   bot's own DM replies from re-triggering the handler.
+ */
+export declare function parseDirectMessageEvent(envelope: SlackEventCallback): SlackMessage | null;
+/**
+ * Verified inbound identity used to render a `<slack_context>` block.
+ *
+ * Channel-owned shape so the helper does not depend on the inbound
+ * `SlackMessage` and is therefore trivially testable in isolation.
+ */
+export interface SlackInboundContext {
+    readonly userId: string;
+    readonly userName?: string;
+    readonly fullName?: string;
+    readonly channelId: string;
+    readonly threadTs: string;
+    readonly teamId?: string;
+}
+/**
+ * Renders one {@link SlackInboundContext} as a `<slack_context>` block.
+ * Lines are deterministic and tag-delimited so the agent can match the
+ * block in its prompt.
+ */
+export declare function formatSlackContextBlock(context: SlackInboundContext): string;

package/dist/src/public/channels/slack/inbound.js

@@ -0,0 +1,2 @@
+import{slackMrkdwnToGfm}from"#public/channels/slack/mrkdwn.js";function parseAppMentionEvent(e){if(e.type!==`event_callback`)return null;let t=e.event;return!t||t.type!==`app_mention`?null:buildSlackMessage(t,e.team_id)}function parseDirectMessageEvent(e){if(e.type!==`event_callback`)return null;let t=e.event;if(!t||t.type!==`message`)return null;let n=t;return n.channel_type!==`im`||typeof n.subtype==`string`&&n.subtype.length>0&&n.subtype!==`file_share`||typeof n.bot_id==`string`&&n.bot_id.length>0?null:buildSlackMessage(n,e.team_id)}function buildSlackMessage(t,n){let r=typeof t.channel==`string`?t.channel:``,i=typeof t.ts==`string`?t.ts:``;if(!r||!i)return null;let a=typeof t.text==`string`?t.text:``,o=typeof t.thread_ts==`string`?t.thread_ts:i,s=typeof n==`string`?n:void 0;return{text:a,markdown:slackMrkdwnToGfm(a),ts:i,threadTs:o,channelId:r,teamId:s,author:parseAuthor(t),attachments:parseAttachments(t.files),raw:t}}function parseAuthor(e){let t=typeof e.user==`string`?e.user:``;if(t)return{userId:t,userName:typeof e.username==`string`?e.username:void 0,fullName:void 0,isBot:typeof e.bot_id==`string`&&e.bot_id.length>0,isMe:!1}}function parseAttachments(e){return Array.isArray(e)?e.map(toAttachment):[]}function toAttachment(e){let t=typeof e.mimetype==`string`?e.mimetype:void 0,n=typeof e.url_private==`string`?e.url_private:void 0;return{id:typeof e.id==`string`?e.id:``,type:inferAttachmentType(t),url:n,name:typeof e.name==`string`?e.name:void 0,mimeType:t,size:typeof e.size==`number`?e.size:void 0}}function inferAttachmentType(e){return e===void 0?`file`:e.startsWith(`image/`)?`image`:e.startsWith(`video/`)?`video`:e.startsWith(`audio/`)?`audio`:`file`}function formatSlackContextBlock(e){return[`<slack_context>`,`user_id: ${e.userId}`,...e.userName?[`user_name: ${e.userName}`]:[],...e.fullName?[`full_name: ${e.fullName}`]:[],`channel_id: ${e.channelId}`,`thread_ts: ${e.threadTs}`,...e.teamId?[`team_id: ${e.teamId}`]:[],`</slack_context>`].join(`
+`)}export{formatSlackContextBlock,parseAppMentionEvent,parseDirectMessageEvent};

package/dist/src/public/channels/slack/index.d.ts

@@ -0,0 +1,22 @@
+/**
+ * AI SDK conversation-message shape that the harness uses as the unit of
+ * session history and turn input. Re-exported from the `ai` package so
+ * authors wiring up the Slack channel can type their own message arrays
+ * without taking a direct `ai` dependency.
+ */
+export type { ModelMessage } from "ai";
+export { slackChannel, type SlackApiResponse, type SlackBotToken, type SlackChannel, type SlackChannelConfig, type SlackChannelCredentials, type SlackChannelEvents, type SlackChannelState, type SlackContext, type SlackEventContext, type SlackHandle, type SlackInboundResult, type SlackInboundResultOrPromise, type SlackInstrumentationMetadata, type SlackInitialMessage, type SlackInteractionAction, type SlackMentionResult, type SlackMentionResultOrPromise, type SlackReceiveTarget, type SlackThread, type SlackWebhookVerifier, } from "#public/channels/slack/slackChannel.js";
+export type { SlackAttachment, SlackAuthor, SlackInboundContext, SlackMessage, } from "#public/channels/slack/inbound.js";
+export { slackContinuationToken, type SlackPostInput, type SlackPostedMessage, type SlackThreadMessage, type SlackUploadFilesOptions, type SlackUploadFilesResult, } from "#public/channels/slack/api.js";
+export { defaultSlackAuth } from "#public/channels/slack/defaults.js";
+export { loadThreadContextMessages, type LoadThreadContextMessagesOptions, type ThreadContextSince, } from "#public/channels/slack/thread.js";
+export { cardToBlocks, cardToFallbackText, type BlockKitBlock, } from "#public/channels/slack/blocks.js";
+/**
+ * Card builders and element types re-exported from the vendored chat
+ * SDK module. These are pure data factories. They return plain typed
+ * objects that the channel passes to {@link cardToBlocks} at post time.
+ * The chat SDK runtime (`Chat`, `Thread`, `Adapter`, etc.) is not
+ * imported and not reachable through this entry point.
+ */
+export { Actions, Button, Card, CardLink, CardText, Divider, ExternalSelect, Field, Fields, Image, LinkButton, Modal, RadioSelect, Section, Select, SelectOption, Table, TextInput, cardChildToFallbackText, isCardElement, } from "#compiled/chat/index.js";
+export type { ActionsElement, AdapterPostableMessage, Attachment, ButtonElement, ButtonOptions, ButtonProps, ButtonStyle, CardChild, CardElement, CardJSXElement, CardJSXProps, CardLinkProps, CardOptions, CardProps, ChatElement, ContainerProps, DividerElement, DividerProps, ExternalSelectElement, ExternalSelectOptions, ExternalSelectProps, FieldElement, FieldProps, FieldsElement, FileUpload, ImageElement, ImageProps, LinkButtonElement, LinkButtonOptions, LinkButtonProps, LinkElement, ModalChild, ModalElement, ModalOptions, ModalProps, PostableCard, RadioSelectElement, RadioSelectOptions, SectionElement, SelectElement, SelectOptionElement, SelectOptionProps, SelectOptions, SelectProps, TableAlignment, TableElement, TableOptions, TextElement, TextInputElement, TextInputOptions, TextInputProps, TextProps, TextStyle, } from "#compiled/chat/index.js";

package/dist/src/public/channels/slack/index.js

@@ -0,0 +1 @@
+import{Actions,Button,Card,CardLink,CardText,Divider,ExternalSelect,Field,Fields,Image,LinkButton,Modal,RadioSelect,Section,Select,SelectOption,Table,TextInput,cardChildToFallbackText,isCardElement}from"#compiled/chat/index.js";import{cardToBlocks,cardToFallbackText}from"#public/channels/slack/blocks.js";import{slackContinuationToken}from"#public/channels/slack/api.js";import{slackChannel}from"#public/channels/slack/slackChannel.js";import{defaultSlackAuth}from"#public/channels/slack/defaults.js";import{loadThreadContextMessages}from"#public/channels/slack/thread.js";export{Actions,Button,Card,CardLink,CardText,Divider,ExternalSelect,Field,Fields,Image,LinkButton,Modal,RadioSelect,Section,Select,SelectOption,Table,TextInput,cardChildToFallbackText,cardToBlocks,cardToFallbackText,defaultSlackAuth,isCardElement,loadThreadContextMessages,slackChannel,slackContinuationToken};

package/dist/src/public/channels/slack/interactions.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Slack `block_actions` + `view_submission` wire handling.
+ *
+ * The route handler reads the form-encoded body, hands it here, and we:
+ *
+ * 1. Decode `block_actions` payloads into a typed shape the channel can
+ *    work with — actions, channel/thread metadata, the clicker, and the
+ *    full original block list for answered-card updates.
+ * 2. Open the freeform-answer modal inline when the click was a "Type
+ *    your answer" button (Slack's `trigger_id` is only valid for ~3s,
+ *    so this can't run under `waitUntil`).
+ * 3. Resolve `view_submission` payloads (freeform modal submissions)
+ *    back into parked HITL requests via `send`.
+ *
+ * Anything we don't consume flows through to the user-supplied
+ * `onInteraction` callback. Always returns `Response("ok")` — followup
+ * work runs under `waitUntil` so the webhook ACK is immediate.
+ */
+import type { SlackChannelConfig, SlackChannelState, SlackInteractionAction } from "#public/channels/slack/slackChannel.js";
+import type { SendFn } from "#public/definitions/defineChannel.js";
+/**
+ * Decoded view of a Slack `block_actions` payload. Returned by
+ * {@link parseBlockActionsPayload} and read by the handler.
+ */
+interface ParsedBlockActionsPayload {
+    readonly actions: SlackInteractionAction[];
+    readonly channelId: string;
+    readonly threadTs: string;
+    readonly teamId: string | undefined;
+    /**
+     * The full block list off the clicked message. Preserved on the
+     * answered-card update so the original prompt stays visible after the
+     * interactive controls are stripped.
+     */
+    readonly messageBlocks: readonly unknown[];
+}
+/**
+ * Decodes a Slack `block_actions` payload into a {@link ParsedBlockActionsPayload}.
+ * Returns `null` for payloads that don't carry the channel/thread
+ * metadata the handler needs.
+ */
+export declare function parseBlockActionsPayload(body: Record<string, unknown>): ParsedBlockActionsPayload | null;
+/**
+ * Channel-supplied dependencies for {@link handleInteractionPost}.
+ *
+ * Carries the bits the handler needs that come from channel
+ * construction: credentials for outbound API calls and the user's
+ * `onInteraction` callback for non-HITL clicks.
+ */
+export interface InteractionHandlerDeps {
+    readonly config: SlackChannelConfig;
+}
+/**
+ * Entry point for Slack's form-encoded interactivity endpoint. Routes
+ * `view_submission` payloads to the freeform-answer flow, intercepts
+ * "Type your answer" button clicks to open a modal, resolves
+ * framework HITL clicks against the parked session, and forwards
+ * anything else to `config.onInteraction`.
+ */
+export declare function handleInteractionPost(rawBody: string, ctx: {
+    send: SendFn<SlackChannelState>;
+    waitUntil: (task: Promise<unknown>) => void;
+}, deps: InteractionHandlerDeps): Promise<Response>;
+export type { ParsedBlockActionsPayload };

package/dist/src/public/channels/slack/interactions.js

@@ -0,0 +1 @@
+import{createLogger}from"#internal/logging.js";import{buildSlackBinding,resolveSlackBotToken,slackContinuationToken}from"#public/channels/slack/api.js";import{buildSlackAuthContext}from"#public/channels/slack/auth.js";import{HITL_FREEFORM_MODAL_ACTION_ID,HITL_FREEFORM_MODAL_BLOCK_ID,HITL_FREEFORM_MODAL_CALLBACK_ID,buildAnsweredBlocks,buildFreeformModalView,deriveHitlResponse,freeformRequestIdFromActionId,isFreeformAction,isHitlAction}from"#public/channels/slack/hitl.js";const log=createLogger(`slack.interactions`);function parseBlockActionsPayload(e){let t=e.actions;if(!Array.isArray(t))return null;let n=e.channel?.id,r=e.message,i=r?.thread_ts??r?.ts;if(!n||!i)return null;let a=e.team,o=e.user,s=a?.id??o.team_id,c={id:o.id,username:o.username,name:o.name},l=r?.blocks??[];return{actions:t.map(e=>({actionId:String(e.action_id??``),value:e.value==null?void 0:String(e.value),blockId:e.block_id==null?void 0:String(e.block_id),selectedOptionValue:extractSelectedOptionValue(e),messageTs:r?.ts,label:extractActionLabel(e),user:c})),channelId:n,threadTs:i,teamId:s,messageBlocks:l}}function extractSelectedOptionValue(e){let t=e.selected_option;return typeof t?.value==`string`?t.value:void 0}function extractActionLabel(e){let t=e.selected_option?.text?.text;if(typeof t==`string`&&t.length>0)return t;let n=e.text?.text;if(typeof n==`string`&&n.length>0)return n}function findPromptBlock(e){for(let t of e)if(typeof t==`object`&&t&&t.type===`section`)return t}function readPromptTextFromBlocks(e){let t=findPromptBlock(e)?.text?.text;return typeof t==`string`&&t.length>0?t:void 0}async function handleInteractionPost(e,n,a){let o=new Response(`ok`,{status:200}),s=new URLSearchParams(e).get(`payload`);if(!s)return o;let c;try{c=JSON.parse(s)}catch{return log.warn(`failed to parse Slack interaction payload`),o}if(c?.type===`view_submission`)return handleViewSubmission(c,n,a);let l=parseBlockActionsPayload(c);if(!l)return o;let d=l.actions.find(e=>isFreeformAction(e.actionId));if(d)return await openFreeformModal({payload:c,interaction:l,freeformAction:d,deps:a}),o;let m=slackContinuationToken(l.channelId,l.threadTs),h=l.actions.map(deriveHitlResponse).filter(e=>e!==null);if(h.length>0){let e=l.actions[0]?.user;if(!e)return o;n.waitUntil(n.send({inputResponses:h},{auth:buildSlackAuthContext({channelId:l.channelId,teamId:l.teamId,threadTs:l.threadTs,userId:e.id,userName:e.username??e.name}),continuationToken:m,state:{channelId:l.channelId,threadTs:l.threadTs,teamId:l.teamId??null,triggeringUserId:e.id}}).catch(e=>{log.error(`HITL interaction delivery failed`,{error:e})})),n.waitUntil(updateAnsweredHitlCard(l,a).catch(e=>{log.error(`HITL answered-card update failed`,{error:e})}))}let g=a.config.onInteraction;if(g){let e=l.actions.filter(e=>!isHitlAction(e.actionId));if(e.length>0){let{thread:r,slack:i}=buildSlackBinding({botToken:a.config.credentials?.botToken,channelId:l.channelId,threadTs:l.threadTs,teamId:l.teamId}),o={thread:r,slack:i};for(let t of e)n.waitUntil(Promise.resolve(g(t,o)).catch(e=>{log.error(`custom interaction handler failed`,{error:e})}))}}return o}async function openFreeformModal(e){let t=e.payload.trigger_id;if(typeof t!=`string`||t.length===0){log.warn(`freeform button click missing trigger_id — cannot open modal`);return}let i=freeformRequestIdFromActionId(e.freeformAction.actionId)??e.freeformAction.value;if(!i){log.warn(`freeform button click missing requestId`);return}let a=e.freeformAction.messageTs;if(!a){log.warn(`freeform button click missing messageTs`);return}let o=buildFreeformModalView({metadata:{continuationToken:slackContinuationToken(e.interaction.channelId,e.interaction.threadTs),channelId:e.interaction.channelId,threadTs:e.interaction.threadTs,messageTs:a,requestId:i},prompt:readPromptTextFromBlocks(e.interaction.messageBlocks)}),s=await resolveSlackBotToken(e.deps.config.credentials?.botToken),c=await fetch(`https://slack.com/api/views.open`,{method:`POST`,headers:{authorization:`Bearer ${s}`,"content-type":`application/json; charset=utf-8`},body:JSON.stringify({trigger_id:t,view:o})});c.ok||log.error(`Slack views.open returned non-2xx`,{status:c.status})}async function handleViewSubmission(e,t,n){let r=new Response(`ok`,{status:200}),c=e.view;if(c?.callback_id!==HITL_FREEFORM_MODAL_CALLBACK_ID)return r;let l;try{l=JSON.parse(c.private_metadata??``)}catch{return log.warn(`freeform view_submission carries invalid private_metadata`),r}if(!l.continuationToken||!l.requestId||!l.messageTs||!l.channelId||!l.threadTs)return r;let u=c.state?.values?.[HITL_FREEFORM_MODAL_BLOCK_ID]?.[HITL_FREEFORM_MODAL_ACTION_ID]?.value,d=typeof u==`string`?u:``;if(d.length===0)return r;let f=e.team,p=e.user,m=p.id,h=p.team_id??f?.id??null;return t.waitUntil(t.send({inputResponses:[{requestId:l.requestId,text:d}]},{auth:buildSlackAuthContext({channelId:l.channelId,teamId:h,threadTs:l.threadTs,userId:p.id,userName:p.username??p.name}),continuationToken:l.continuationToken,state:{channelId:l.channelId,threadTs:l.threadTs,teamId:h,triggeringUserId:m}}).catch(e=>{log.error(`freeform answer delivery failed`,{error:e})})),t.waitUntil(updateAnsweredFreeformCard({channelId:l.channelId,messageTs:l.messageTs,answerLabel:d,userId:m??void 0,deps:n}).catch(e=>{log.error(`freeform answered-card update failed`,{error:e})})),r}async function updateAnsweredHitlCard(e,t){let r=e.actions.find(e=>isHitlAction(e.actionId));if(!r||!r.messageTs)return;let i=r.label??r.selectedOptionValue??r.value;if(!i)return;let a=buildAnsweredBlocks({promptBlock:findPromptBlock(e.messageBlocks),answerLabel:i,userId:r.user.id}),o=await resolveSlackBotToken(t.config.credentials?.botToken),s=await fetch(`https://slack.com/api/chat.update`,{method:`POST`,headers:{authorization:`Bearer ${o}`,"content-type":`application/json; charset=utf-8`},body:JSON.stringify({channel:e.channelId,ts:r.messageTs,blocks:a,text:`Answered: ${i}`})});if(!s.ok)throw Error(`Slack chat.update returned HTTP ${s.status}`)}async function updateAnsweredFreeformCard(e){let t=buildAnsweredBlocks({promptBlock:void 0,answerLabel:e.answerLabel,userId:e.userId}),r=await resolveSlackBotToken(e.deps.config.credentials?.botToken),i=await fetch(`https://slack.com/api/chat.update`,{method:`POST`,headers:{authorization:`Bearer ${r}`,"content-type":`application/json; charset=utf-8`},body:JSON.stringify({channel:e.channelId,ts:e.messageTs,blocks:t,text:`Answered: ${e.answerLabel}`})});if(!i.ok)throw Error(`Slack chat.update returned HTTP ${i.status}`)}export{handleInteractionPost,parseBlockActionsPayload};

package/dist/src/public/channels/slack/limits.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Slack API string-length guards.
+ *
+ * Slack rejects payloads where a string exceeds its surface-specific
+ * limit (typing indicator, Block Kit `plain_text` fields, modal titles,
+ * etc.). The chat SDK does not enforce these for us — anything that
+ * overruns surfaces as a `chat.postMessage` / `assistant.threads.setStatus`
+ * / `views.open` HTTP error. These helpers cap strings before they cross
+ * the wire so a single long tool name or option label cannot fail the
+ * whole event handler.
+ */
+/**
+ * Typing indicator (`assistant.threads.setStatus`) caps at roughly 100
+ * characters; we use 50 to match the pre-existing UX (statuses longer
+ * than a glance are hard to read in the chat UI anyway).
+ */
+export declare const SLACK_TYPING_STATUS_MAX_LENGTH = 50;
+/**
+ * Block Kit `plain_text` fields used in `static_select` / `radio_buttons`
+ * options and button labels are capped at 75 characters by Slack.
+ */
+export declare const SLACK_BLOCK_KIT_PLAIN_TEXT_MAX_LENGTH = 75;
+/**
+ * Block Kit `section` blocks cap `text.text` at 3000 chars. Anything
+ * longer fails the whole post with `invalid_blocks`.
+ */
+export declare const SLACK_SECTION_TEXT_MAX_LENGTH = 3000;
+/**
+ * Top-level `text` field on `chat.postMessage` is capped at 40000 chars.
+ */
+export declare const SLACK_MESSAGE_TEXT_MAX_LENGTH = 40000;
+/**
+ * `views.open` modal title is capped at 24 characters.
+ */
+export declare const SLACK_MODAL_TITLE_MAX_LENGTH = 24;
+/**
+ * Normalizes a typing status: trims, collapses runs of whitespace into a
+ * single space, then truncates to {@link SLACK_TYPING_STATUS_MAX_LENGTH}
+ * with a trailing ellipsis when needed.
+ */
+export declare function truncateTypingStatus(status: string): string;
+/**
+ * Caps a Block Kit `plain_text` label/description at the Slack limit
+ * with a trailing ellipsis. Pass `undefined` to short-circuit (option
+ * descriptions are optional).
+ */
+export declare function truncatePlainText(value: string): string;
+export declare function truncatePlainText(value: string | undefined): string | undefined;
+/**
+ * Caps a section block's `text.text` at the Slack limit with a
+ * trailing ellipsis.
+ */
+export declare function truncateSectionText(value: string): string;
+/**
+ * Caps a `chat.postMessage` `text` field at the Slack limit with a
+ * trailing ellipsis.
+ */
+export declare function truncateMessageText(value: string): string;
+/**
+ * Caps a modal title at the Slack limit with a trailing ellipsis.
+ */
+export declare function truncateModalTitle(value: string): string;

package/dist/src/public/channels/slack/limits.js

@@ -0,0 +1 @@
+const SLACK_TYPING_STATUS_MAX_LENGTH=50,SLACK_BLOCK_KIT_PLAIN_TEXT_MAX_LENGTH=75,SLACK_SECTION_TEXT_MAX_LENGTH=3e3,SLACK_MESSAGE_TEXT_MAX_LENGTH=4e4,SLACK_MODAL_TITLE_MAX_LENGTH=24;function truncateTypingStatus(e){return truncateWithEllipsis(e.trim().replace(/\s+/gu,` `),50)}function truncatePlainText(e){if(e!==void 0)return truncateWithEllipsis(e,75)}function truncateSectionText(e){return truncateWithEllipsis(e,SLACK_SECTION_TEXT_MAX_LENGTH)}function truncateMessageText(e){return truncateWithEllipsis(e,SLACK_MESSAGE_TEXT_MAX_LENGTH)}function truncateModalTitle(e){return truncateWithEllipsis(e,24)}function truncateWithEllipsis(e,t){if(e.length<=t)return e;let n=Math.max(0,t-3);return`${e.slice(0,n).trimEnd()}...`}export{SLACK_BLOCK_KIT_PLAIN_TEXT_MAX_LENGTH,SLACK_MESSAGE_TEXT_MAX_LENGTH,SLACK_MODAL_TITLE_MAX_LENGTH,SLACK_SECTION_TEXT_MAX_LENGTH,SLACK_TYPING_STATUS_MAX_LENGTH,truncateMessageText,truncateModalTitle,truncatePlainText,truncateSectionText,truncateTypingStatus};

package/dist/src/public/channels/slack/mrkdwn.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Slack mrkdwn ↔ GitHub-flavored markdown converters and the bare
+ * `@mention` rewriter used by the outbound post pipeline. These are
+ * pure string utilities — no Slack API I/O, no I/O at all — so they
+ * live separately from the binding constructor and request shape code
+ * in {@link ./api.ts}.
+ */
+/**
+ * Rewrites bare `@USER_ID` tokens (the form Slack apps and humans tend
+ * to type) into the `<@USER_ID>` mention syntax Slack actually renders.
+ * Anything already wrapped in `<...>` is left untouched.
+ */
+export declare function rewriteBareMentions(text: string): string;
+/**
+ * Best-effort GFM → Slack mrkdwn converter used only in contexts that
+ * do not support `markdown_text` (e.g. `files.completeUploadExternal`'s
+ * `initial_comment` field).
+ *
+ * The main `{ markdown }` post path sends `markdown_text` directly
+ * to `chat.postMessage` and does not go through this converter.
+ */
+export declare function gfmToSlackMrkdwn(input: string): string;
+/**
+ * Best-effort Slack mrkdwn → GFM converter applied to the text of
+ * every inbound Slack message before the harness sees it.
+ *
+ * - `<@U123>`              → `@U123`
+ * - `<#C123|name>`         → `#name` (or `#C123` when no name)
+ * - `<!channel>` etc.      → `@channel`
+ * - `<https://x|label>`    → `[label](https://x)`
+ * - `<https://x>`          → `https://x`
+ * - `*bold*` (paired)      → `**bold**`
+ * - `~strike~` (paired)    → `~~strike~~`
+ *
+ * Inline `_italic_` and code spans pass through unchanged because both
+ * formats render them identically.
+ */
+export declare function slackMrkdwnToGfm(input: string): string;

package/dist/src/public/channels/slack/mrkdwn.js

@@ -0,0 +1 @@
+const BARE_MENTION_RE=/(?<![<\w])@(\w+)/gu;function rewriteBareMentions(t){return t.replace(BARE_MENTION_RE,`<@$1>`)}function gfmToSlackMrkdwn(e){return splitCodeFences(e).map(e=>e.kind===`code`?e.text:convertInline(e.text)).join(``)}function slackMrkdwnToGfm(e){return splitCodeFences(e).map(e=>e.kind===`code`?e.text:decodeInline(e.text)).join(``)}function splitCodeFences(e){let t=[],n=/```[\s\S]*?```|`[^`\n]+`/gu,r=0;for(let i of e.matchAll(n)){let n=i.index??0;n>r&&t.push({kind:`text`,text:e.slice(r,n)}),t.push({kind:`code`,text:i[0]}),r=n+i[0].length}return r<e.length&&t.push({kind:`text`,text:e.slice(r)}),t}function convertInline(e){let t=e;return t=t.replace(/\*\*([^*\n]+)\*\*/gu,`*$1*`),t=t.replace(/__([^_\n]+)__/gu,`*$1*`),t=t.replace(/~~([^~\n]+)~~/gu,`~$1~`),t=t.replace(/\[([^\]\n]+)\]\(([^)\s]+)\)/gu,`<$2|$1>`),t}function decodeInline(e){let t=e;return t=t.replace(/<!(channel|here|everyone)>/gu,`@$1`),t=t.replace(/<@([A-Z0-9]+)\|([^>]+)>/gu,`@$2`),t=t.replace(/<@([A-Z0-9]+)>/gu,`@$1`),t=t.replace(/<#([A-Z0-9]+)\|([^>]+)>/gu,`#$2`),t=t.replace(/<#([A-Z0-9]+)>/gu,`#$1`),t=t.replace(/<(https?:\/\/[^|>\s]+)\|([^>]+)>/gu,`[$2]($1)`),t=t.replace(/<(https?:\/\/[^>\s]+)>/gu,`$1`),t=t.replace(/(^|[^*])\*([^*\n]+)\*(?!\*)/gu,`$1**$2**`),t=t.replace(/(^|[^~])~([^~\n]+)~(?!~)/gu,`$1~~$2~~`),t}export{gfmToSlackMrkdwn,rewriteBareMentions,slackMrkdwnToGfm};