@cuylabs/channel-slack 0.8.0 → 0.9.0

package/README.md

@@ -4,8 +4,9 @@ Agent-runtime-agnostic Slack channel primitives.
 
 This package owns reusable Slack mechanics: event parsing, message admission,
 history loading, formatting, setup inspection, auth helpers, entrypoint
-normalization, artifact publishing, and HTTP or Socket Mode transport helpers.
-It does not create or run an agent, and it does not depend on an agent SDK.
+normalization, artifact publishing, interactive request rendering/storage,
+response sink contracts, and HTTP or Socket Mode transport helpers. It does not
+create or run an agent, and it does not depend on an agent SDK.
 
 Runtime-specific adapters should compose these primitives with their own turn
 types, event streams, tools, prompts, and deployment policy.

package/dist/artifacts/index.d.ts

@@ -1,112 +1,5 @@
-type SlackArtifactPublishMethod = "message" | "file" | "canvas";
-type SlackArtifactBinaryData = string | Uint8Array | ArrayBuffer;
-interface SlackArtifactBase {
-    kind: string;
-    title: string;
-    summary?: string;
-    metadata?: Record<string, unknown>;
-}
-interface SlackTextArtifact extends SlackArtifactBase {
-    kind: "text";
-    text: string;
-    filename?: string;
-    mimeType?: string;
-    publishAs?: "message" | "file";
-}
-interface SlackFileArtifact extends SlackArtifactBase {
-    kind: "file";
-    filename: string;
-    data?: SlackArtifactBinaryData;
-    filePath?: string;
-    mimeType?: string;
-    initialComment?: string;
-}
-interface SlackImageArtifact extends SlackArtifactBase {
-    kind: "image";
-    filename: string;
-    altText: string;
-    data?: SlackArtifactBinaryData;
-    filePath?: string;
-    initialComment?: string;
-}
-interface SlackLinkArtifact extends SlackArtifactBase {
-    kind: "link";
-    url: string;
-}
-interface SlackCanvasArtifact extends SlackArtifactBase {
-    kind: "canvas";
-    markdown: string;
-    /**
-     * When set, updates an existing canvas instead of creating one.
-     */
-    canvasId?: string;
-    /**
-     * Create a channel canvas when a channel is available.
-     *
-     * @default true
-     */
-    channelCanvas?: boolean;
-}
-type SlackArtifact = SlackTextArtifact | SlackFileArtifact | SlackImageArtifact | SlackLinkArtifact | SlackCanvasArtifact;
-interface SlackArtifactPostMessageResponse {
-    ok?: boolean;
-    channel?: string;
-    ts?: string;
-    [key: string]: unknown;
-}
-interface SlackArtifactFileUploadResponse {
-    ok?: boolean;
-    file?: {
-        id?: string;
-        [key: string]: unknown;
-    };
-    files?: Array<{
-        id?: string;
-        [key: string]: unknown;
-    }>;
-    [key: string]: unknown;
-}
-interface SlackArtifactCanvasResponse {
-    ok?: boolean;
-    canvas_id?: string;
-    [key: string]: unknown;
-}
-interface SlackArtifactClient {
-    chat?: {
-        postMessage(args: Record<string, unknown>): Promise<SlackArtifactPostMessageResponse>;
-    };
-    files?: {
-        uploadV2(args: Record<string, unknown>): Promise<SlackArtifactFileUploadResponse>;
-    };
-    canvases?: {
-        create(args?: Record<string, unknown>): Promise<SlackArtifactCanvasResponse>;
-        edit?(args: Record<string, unknown>): Promise<SlackArtifactCanvasResponse>;
-    };
-    conversations?: {
-        canvases?: {
-            create(args: Record<string, unknown>): Promise<SlackArtifactCanvasResponse>;
-        };
-    };
-}
-interface PublishSlackArtifactOptions {
-    client: SlackArtifactClient;
-    artifact: SlackArtifact;
-    channelId?: string;
-    threadTs?: string;
-    token?: string;
-    unfurlLinks?: boolean;
-    unfurlMedia?: boolean;
-}
-interface SlackArtifactPublication {
-    artifact: SlackArtifact;
-    method: SlackArtifactPublishMethod;
-    response: unknown;
-    channelId?: string;
-    threadTs?: string;
-    messageTs?: string;
-    fileId?: string;
-    canvasId?: string;
-}
+import { S as SlackArtifact, l as SlackLinkArtifact, P as PublishSlackArtifactOptions, g as SlackArtifactPublication, i as SlackCanvasArtifact, j as SlackFileArtifact, k as SlackImageArtifact, m as SlackTextArtifact } from '../types-C8nkPuD4.js';
+export { a as SlackArtifactBase, b as SlackArtifactBinaryData, c as SlackArtifactCanvasResponse, d as SlackArtifactClient, e as SlackArtifactFileUploadResponse, f as SlackArtifactPostMessageResponse, h as SlackArtifactPublishMethod } from '../types-C8nkPuD4.js';
 
 interface SlackArtifactBlockKitMessage {
     text: string;
@@ -132,4 +25,4 @@ declare function publishSlackCanvasArtifact(options: PublishSlackArtifactOptions
     artifact: SlackCanvasArtifact;
 }): Promise<SlackArtifactPublication>;
 
-export { type PublishSlackArtifactOptions, type SlackArtifact, type SlackArtifactBase, type SlackArtifactBinaryData, type SlackArtifactBlockKitMessage, type SlackArtifactCanvasResponse, type SlackArtifactClient, type SlackArtifactFileUploadResponse, type SlackArtifactPostMessageResponse, type SlackArtifactPublication, type SlackArtifactPublishMethod, type SlackCanvasArtifact, type SlackFileArtifact, type SlackImageArtifact, type SlackLinkArtifact, type SlackTextArtifact, createSlackArtifactBlocks, createSlackLinkArtifactBlocks, publishSlackArtifact, publishSlackCanvasArtifact, publishSlackFileArtifact, publishSlackImageArtifact, publishSlackLinkArtifact, publishSlackTextArtifact };
+export { PublishSlackArtifactOptions, SlackArtifact, type SlackArtifactBlockKitMessage, SlackArtifactPublication, SlackCanvasArtifact, SlackFileArtifact, SlackImageArtifact, SlackLinkArtifact, SlackTextArtifact, createSlackArtifactBlocks, createSlackLinkArtifactBlocks, publishSlackArtifact, publishSlackCanvasArtifact, publishSlackFileArtifact, publishSlackImageArtifact, publishSlackLinkArtifact, publishSlackTextArtifact };

package/dist/core.d.ts

@@ -1,4 +1,5 @@
 import { S as SlackActivityInfo, b as SlackUserIdentity, a as SlackChannelType } from './activity-ByrD9Ftr.js';
+export { S as SlackApprovalRequest, a as SlackEventInteractiveRequestHandler, b as SlackHumanInputRequest, c as SlackInteractiveMessage, d as SlackInteractiveMessageRef, e as SlackInteractiveRequest, f as SlackInteractiveRequestBaseContext, g as SlackInteractiveRequestContext, h as SlackInteractiveRequestHandler, i as SlackInteractiveRequestKind, j as SlackInteractiveResponder } from './interactive-CbKYkkc_.js';
 export { RegisterSlackTurnCancelActionOptions, SLACK_TURN_CANCEL_ACTION_ID, SlackTurnCancelActionContext, SlackTurnCancelActionHandler, SlackTurnCancelButtonValue, SlackTurnCancelMessage, SlackTurnCancelMessageOptions, createSlackTurnCancelMessage, decodeSlackTurnCancelButtonValue, encodeSlackTurnCancelButtonValue, registerSlackTurnCancelAction, resolveSlackTurnCancelActionId } from './turn-controls/index.js';
 import '@slack/types';
 import '@slack/bolt';
@@ -178,45 +179,6 @@ interface SlackTurnPreparation {
     context?: Record<string, unknown>;
 }
 
-/**
- * Transport-neutral interactive request contracts.
- *
- * These types let callers delegate approval and human-input requests to a
- * Slack-specific renderer without importing Bolt or Web API types into
- * `shared/`.
- */
-
-type SlackInteractiveRequestKind = "approval" | "human-input";
-type SlackApprovalRequest = Record<string, unknown>;
-type SlackHumanInputRequest = Record<string, unknown>;
-type SlackInteractiveRequest = SlackApprovalRequest | SlackHumanInputRequest;
-interface SlackInteractiveMessageRef {
-    channel: string;
-    ts: string;
-}
-interface SlackInteractiveMessage {
-    text: string;
-    blocks?: unknown[];
-}
-interface SlackInteractiveResponder {
-    postMessage(message: SlackInteractiveMessage): Promise<SlackInteractiveMessageRef>;
-    updateMessage(ref: SlackInteractiveMessageRef, message: SlackInteractiveMessage): Promise<void>;
-}
-interface SlackInteractiveRequestBaseContext {
-    kind: SlackInteractiveRequestKind;
-    request: SlackInteractiveRequest;
-    fallbackText: string;
-}
-interface SlackInteractiveRequestContext extends SlackInteractiveRequestBaseContext {
-    slackActivity: SlackActivityInfo;
-    user: SlackUserIdentity;
-    sessionId: string;
-    message: string;
-    responder: SlackInteractiveResponder;
-}
-type SlackInteractiveRequestHandler = (context: SlackInteractiveRequestContext) => boolean | void | Promise<boolean | void>;
-type SlackEventInteractiveRequestHandler = (context: SlackInteractiveRequestBaseContext) => boolean | void | Promise<boolean | void>;
-
 /**
  * Raw Slack event payload parsers — produce `SlackActivityInfo` from the
  * shapes Bolt delivers for `message` and `app_mention` events.
@@ -425,4 +387,4 @@ interface SlackAmbientTurnContext extends SlackTurnRequestContext {
 declare function currentSlackTurnContext(): Readonly<SlackAmbientTurnContext> | undefined;
 declare function runWithSlackTurnContext<T>(value: SlackAmbientTurnContext, fn: () => T | Promise<T>): Promise<T>;
 
-export { type ExtractSlackMessageTextOptions, type RawSlackActionTokenPayload, type RawSlackAppMentionPayload, type RawSlackAssistantThreadPayload, type RawSlackMessagePayload, SlackActivityInfo, type SlackAmbientTurnContext, type SlackApprovalRequest, type SlackAssistantStatusUpdate, type SlackAssistantSuggestedPrompt, type SlackAssistantSuggestedPrompts, type SlackAssistantTaskDisplayMode, type SlackAssistantThreadContext, type SlackAssistantUtilities, type SlackAuthContext, SlackChannelType, type SlackChatStreamStartArgs, type SlackEventInteractiveRequestHandler, type SlackHumanInputRequest, type SlackInteractiveMessage, type SlackInteractiveMessageRef, type SlackInteractiveRequest, type SlackInteractiveRequestBaseContext, type SlackInteractiveRequestContext, type SlackInteractiveRequestHandler, type SlackInteractiveRequestKind, type SlackInteractiveResponder, type SlackMessageAuthorshipOptions, type SlackMessageFormatter, type SlackMessageFormattingOptions, type SlackMessageTextPayload, type SlackThreadStatusSetter, type SlackTurnPreparation, type SlackTurnRequestContext, SlackUserIdentity, currentSlackTurnContext, extractSlackActionToken, extractSlackAttachmentsText, extractSlackAuthContext, extractSlackBlocksText, extractSlackMessageText, extractSlackUserIdentity, formatSlackAttributedFollowUp, isProcessableMessage, markdownToSlackMrkdwn, parseSlackMentionActivity, parseSlackMessageActivity, resolveSlackChannelType, resolveSlackMessageFormatter, resolveThreadAwareSlackSessionId, runWithSlackTurnContext, stripLeadingMentions };
+export { type ExtractSlackMessageTextOptions, type RawSlackActionTokenPayload, type RawSlackAppMentionPayload, type RawSlackAssistantThreadPayload, type RawSlackMessagePayload, SlackActivityInfo, type SlackAmbientTurnContext, type SlackAssistantStatusUpdate, type SlackAssistantSuggestedPrompt, type SlackAssistantSuggestedPrompts, type SlackAssistantTaskDisplayMode, type SlackAssistantThreadContext, type SlackAssistantUtilities, type SlackAuthContext, SlackChannelType, type SlackChatStreamStartArgs, type SlackMessageAuthorshipOptions, type SlackMessageFormatter, type SlackMessageFormattingOptions, type SlackMessageTextPayload, type SlackThreadStatusSetter, type SlackTurnPreparation, type SlackTurnRequestContext, SlackUserIdentity, currentSlackTurnContext, extractSlackActionToken, extractSlackAttachmentsText, extractSlackAuthContext, extractSlackBlocksText, extractSlackMessageText, extractSlackUserIdentity, formatSlackAttributedFollowUp, isProcessableMessage, markdownToSlackMrkdwn, parseSlackMentionActivity, parseSlackMessageActivity, resolveSlackChannelType, resolveSlackMessageFormatter, resolveThreadAwareSlackSessionId, runWithSlackTurnContext, stripLeadingMentions };

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 export { S as SlackActivityInfo, a as SlackChannelType, b as SlackUserIdentity } from './activity-ByrD9Ftr.js';
-export { ExtractSlackMessageTextOptions, RawSlackActionTokenPayload, RawSlackAppMentionPayload, RawSlackAssistantThreadPayload, RawSlackMessagePayload, SlackAmbientTurnContext, SlackApprovalRequest, SlackAssistantStatusUpdate, SlackAssistantSuggestedPrompt, SlackAssistantSuggestedPrompts, SlackAssistantTaskDisplayMode, SlackAssistantThreadContext, SlackAssistantUtilities, SlackAuthContext, SlackChatStreamStartArgs, SlackEventInteractiveRequestHandler, SlackHumanInputRequest, SlackInteractiveMessage, SlackInteractiveMessageRef, SlackInteractiveRequest, SlackInteractiveRequestBaseContext, SlackInteractiveRequestContext, SlackInteractiveRequestHandler, SlackInteractiveRequestKind, SlackInteractiveResponder, SlackMessageAuthorshipOptions, SlackMessageFormatter, SlackMessageFormattingOptions, SlackMessageTextPayload, SlackThreadStatusSetter, SlackTurnPreparation, SlackTurnRequestContext, currentSlackTurnContext, extractSlackActionToken, extractSlackAttachmentsText, extractSlackAuthContext, extractSlackBlocksText, extractSlackMessageText, extractSlackUserIdentity, formatSlackAttributedFollowUp, isProcessableMessage, markdownToSlackMrkdwn, parseSlackMentionActivity, parseSlackMessageActivity, resolveSlackChannelType, resolveSlackMessageFormatter, resolveThreadAwareSlackSessionId, runWithSlackTurnContext, stripLeadingMentions } from './core.js';
+export { ExtractSlackMessageTextOptions, RawSlackActionTokenPayload, RawSlackAppMentionPayload, RawSlackAssistantThreadPayload, RawSlackMessagePayload, SlackAmbientTurnContext, SlackAssistantStatusUpdate, SlackAssistantSuggestedPrompt, SlackAssistantSuggestedPrompts, SlackAssistantTaskDisplayMode, SlackAssistantThreadContext, SlackAssistantUtilities, SlackAuthContext, SlackChatStreamStartArgs, SlackMessageAuthorshipOptions, SlackMessageFormatter, SlackMessageFormattingOptions, SlackMessageTextPayload, SlackThreadStatusSetter, SlackTurnPreparation, SlackTurnRequestContext, currentSlackTurnContext, extractSlackActionToken, extractSlackAttachmentsText, extractSlackAuthContext, extractSlackBlocksText, extractSlackMessageText, extractSlackUserIdentity, formatSlackAttributedFollowUp, isProcessableMessage, markdownToSlackMrkdwn, parseSlackMentionActivity, parseSlackMessageActivity, resolveSlackChannelType, resolveSlackMessageFormatter, resolveThreadAwareSlackSessionId, runWithSlackTurnContext, stripLeadingMentions } from './core.js';
+export { S as SlackApprovalRequest, a as SlackEventInteractiveRequestHandler, b as SlackHumanInputRequest, c as SlackInteractiveMessage, d as SlackInteractiveMessageRef, e as SlackInteractiveRequest, f as SlackInteractiveRequestBaseContext, g as SlackInteractiveRequestContext, h as SlackInteractiveRequestHandler, i as SlackInteractiveRequestKind, j as SlackInteractiveResponder } from './interactive-CbKYkkc_.js';
 export { RegisterSlackTurnCancelActionOptions, SLACK_TURN_CANCEL_ACTION_ID, SlackTurnCancelActionContext, SlackTurnCancelActionHandler, SlackTurnCancelButtonValue, SlackTurnCancelMessage, SlackTurnCancelMessageOptions, createSlackTurnCancelMessage, decodeSlackTurnCancelButtonValue, encodeSlackTurnCancelButtonValue, registerSlackTurnCancelAction, resolveSlackTurnCancelActionId } from './turn-controls/index.js';
 export { InMemorySlackThreadParticipationStateStoreOptions, PostgresSlackMessagePolicyPruneResult, PostgresSlackMessagePolicyStateStore, PostgresSlackMessagePolicyStateStoreOptions, PostgresSlackThreadParticipationStateStore, PostgresSlackThreadParticipationStateStoreOptions, SlackAsyncMessagePolicyConfig, SlackAsyncMessagePolicyResolver, SlackChannelMessagePolicy, SlackMentionedThreadState, SlackMessagePolicyAcceptReason, SlackMessagePolicyAcceptedDecision, SlackMessagePolicyConfig, SlackMessagePolicyDecision, SlackMessagePolicyPostgresClient, SlackMessagePolicyRejectReason, SlackMessagePolicyRejectedDecision, SlackMessagePolicyResolver, SlackMessagePolicyStateContext, SlackMessagePolicyStateStore, SlackQuietThreadRejectedDecision, SlackSyncMessagePolicyStateStore, SlackThreadAwareMessagePolicyConfig, SlackThreadAwareMessagePolicyDecision, SlackThreadAwareMessagePolicyResolver, SlackThreadParticipationEligibility, SlackThreadParticipationEligibilityOptions, SlackThreadParticipationMode, SlackThreadParticipationPostgresClient, SlackThreadParticipationPruneResult, SlackThreadParticipationReactivation, SlackThreadParticipationState, SlackThreadParticipationStateContext, SlackThreadParticipationStateStore, SlackThreadReplyPolicy, createAsyncSlackMessagePolicyResolver, createAsyncSlackThreadAwareMessagePolicyResolver, createInMemorySlackMessagePolicyStateStore, createInMemorySlackThreadParticipationStateStore, createPostgresSlackMessagePolicyStateStore, createPostgresSlackThreadParticipationStateStore, createSlackMessagePolicyMessageKey, createSlackMessagePolicyResolver, createSlackMessagePolicyThreadKey, initializePostgresSlackMessagePolicyState, initializePostgresSlackThreadParticipationState, prunePostgresSlackMessagePolicyState, prunePostgresSlackThreadParticipationState, resolveSlackThreadParticipationEligibility, shouldRegisterSlackPassiveChannelMessages } from './policy/index.js';
 export { L as Logger } from './logging-Bl3HfcC8.js';

package/dist/interactive/index.d.ts

@@ -0,0 +1,154 @@
+import { g as SlackInteractiveRequestContext } from '../interactive-CbKYkkc_.js';
+export { c as SlackInteractiveMessage, d as SlackInteractiveMessageRef, f as SlackInteractiveRequestBaseContext, i as SlackInteractiveRequestKind, j as SlackInteractiveResponder } from '../interactive-CbKYkkc_.js';
+import { View } from '@slack/types';
+import '../activity-ByrD9Ftr.js';
+
+type SlackInteractiveRequestStatus = "pending" | "resolved";
+type SlackInteractiveApprovalAction = "allow" | "deny" | "remember";
+type SlackInteractiveHumanInputResponse = {
+    kind: "text";
+    text: string;
+} | {
+    kind: "confirm";
+    confirmed: boolean;
+    text: string;
+} | {
+    kind: "choice";
+    selected: string[];
+    text: string;
+};
+interface SlackInteractiveApprovalRequest {
+    id: string;
+    tool: string;
+    args: unknown;
+    description: string;
+    risk: string;
+    rememberScopes?: string[];
+    defaultRememberScope?: string;
+}
+interface SlackInteractiveHumanInputOption {
+    label: string;
+    value?: string;
+    description?: string;
+}
+interface SlackInteractiveHumanInputRequest {
+    id: string;
+    kind: "text" | "confirm" | "choice";
+    title: string;
+    question: string;
+    options?: SlackInteractiveHumanInputOption[];
+    allowMultiple?: boolean;
+    placeholder?: string;
+    confirmLabel?: string;
+    denyLabel?: string;
+}
+type SlackInteractiveStoredRequest = SlackInteractiveApprovalRequest | SlackInteractiveHumanInputRequest;
+type SlackInteractiveResolution = {
+    kind: "approval";
+    action: SlackInteractiveApprovalAction;
+    feedback?: string;
+    rememberScope?: string;
+} | {
+    kind: "human-input";
+    response: SlackInteractiveHumanInputResponse;
+};
+interface SlackInteractiveMessageTarget {
+    channel: string;
+    ts: string;
+    threadTs?: string;
+    userId: string;
+    teamId?: string;
+}
+interface SlackInteractiveRequestRecord {
+    id: string;
+    kind: SlackInteractiveResolution["kind"];
+    request: SlackInteractiveStoredRequest;
+    status: SlackInteractiveRequestStatus;
+    createdAt: string;
+    updatedAt: string;
+    target?: SlackInteractiveMessageTarget;
+    resolution?: SlackInteractiveResolution;
+}
+interface SlackInteractiveRequestStore {
+    get(requestId: string): Promise<SlackInteractiveRequestRecord | undefined>;
+    upsert(record: SlackInteractiveRequestRecord): Promise<SlackInteractiveRequestRecord>;
+    attachTarget(requestId: string, target: SlackInteractiveMessageTarget): Promise<SlackInteractiveRequestRecord | undefined>;
+    resolve(requestId: string, resolution: SlackInteractiveResolution): Promise<SlackInteractiveRequestRecord | undefined>;
+    delete(requestId: string): Promise<void>;
+}
+interface SlackInteractiveActionIds {
+    approvalAllow: string;
+    approvalDeny: string;
+    approvalRemember: string;
+    humanConfirm: string;
+    humanDeny: string;
+    humanOpen: string;
+    humanSubmit: string;
+}
+interface SlackInteractiveActor {
+    userId: string;
+    teamId?: string;
+}
+type SlackInteractiveRequestHandler = (context: SlackInteractiveRequestContext) => boolean | void | Promise<boolean | void>;
+
+declare function buildApprovalRequestMessage(request: SlackInteractiveApprovalRequest, actionIds: SlackInteractiveActionIds): {
+    text: string;
+    blocks: unknown[];
+};
+declare function buildHumanInputRequestMessage(request: SlackInteractiveHumanInputRequest, actionIds: SlackInteractiveActionIds): {
+    text: string;
+    blocks: unknown[];
+};
+declare function buildResolvedMessage(label: string, resolution: SlackInteractiveResolution): {
+    text: string;
+    blocks: unknown[];
+};
+declare function buildHumanInputModal(request: SlackInteractiveHumanInputRequest, actionIds: SlackInteractiveActionIds): View;
+declare function encodeActionValue(payload: Record<string, unknown>): string;
+declare function decodeActionValue(value: unknown): Record<string, unknown>;
+
+declare function createInMemorySlackInteractiveRequestStore(): SlackInteractiveRequestStore;
+declare function nowIso(): string;
+declare function cloneRecord(record: SlackInteractiveRequestRecord): SlackInteractiveRequestRecord;
+
+interface SlackInteractivePostgresClient {
+    end?: () => Promise<void>;
+    query<T = unknown>(sql: string, values?: readonly unknown[]): Promise<{
+        rows: T[];
+        rowCount?: number | null;
+    }>;
+}
+interface PostgresSlackInteractiveRequestStoreOptions {
+    client?: SlackInteractivePostgresClient;
+    connectionString?: string;
+    ensureSchema?: boolean;
+    onPruneError?: (error: unknown) => void;
+    pruneBatchSize?: number;
+    pruneIntervalMs?: number;
+    retentionMs?: number;
+    schema?: string;
+    tableName?: string;
+}
+interface PostgresSlackInteractiveRequestStore extends SlackInteractiveRequestStore {
+    close(): Promise<void>;
+    prune(): Promise<PostgresSlackInteractiveRequestPruneResult>;
+}
+interface PostgresSlackInteractiveRequestPruneResult {
+    deleted: number;
+}
+declare function createPostgresSlackInteractiveRequestStore({ client, connectionString, ensureSchema, onPruneError, pruneBatchSize, pruneIntervalMs, retentionMs, schema, tableName, }: PostgresSlackInteractiveRequestStoreOptions): PostgresSlackInteractiveRequestStore;
+declare function initializePostgresSlackInteractiveRequestStore({ client, ensureSchema, schema, tableName, }: {
+    client: SlackInteractivePostgresClient;
+    ensureSchema?: boolean;
+    schema?: string;
+    tableName?: string;
+}): Promise<void>;
+declare function prunePostgresSlackInteractiveRequestStore({ client, pruneBatchSize, retentionMs, schema, tableName, }: {
+    client: SlackInteractivePostgresClient;
+    pruneBatchSize?: number;
+    retentionMs?: number;
+    schema?: string;
+    tableName?: string;
+}): Promise<PostgresSlackInteractiveRequestPruneResult>;
+
+export { type PostgresSlackInteractiveRequestPruneResult, type PostgresSlackInteractiveRequestStore, type PostgresSlackInteractiveRequestStoreOptions, type SlackInteractiveActionIds, type SlackInteractiveActor, type SlackInteractiveApprovalAction, type SlackInteractiveApprovalRequest, type SlackInteractiveHumanInputOption, type SlackInteractiveHumanInputRequest, type SlackInteractiveHumanInputResponse, type SlackInteractiveMessageTarget, type SlackInteractivePostgresClient, SlackInteractiveRequestContext, type SlackInteractiveRequestHandler, type SlackInteractiveRequestRecord, type SlackInteractiveRequestStatus, type SlackInteractiveRequestStore, type SlackInteractiveResolution, type SlackInteractiveStoredRequest, buildApprovalRequestMessage, buildHumanInputModal, buildHumanInputRequestMessage, buildResolvedMessage, cloneRecord, createInMemorySlackInteractiveRequestStore, createPostgresSlackInteractiveRequestStore, decodeActionValue, encodeActionValue, initializePostgresSlackInteractiveRequestStore, nowIso, prunePostgresSlackInteractiveRequestStore };

package/dist/interactive/index.js

@@ -0,0 +1,650 @@
+// src/interactive/blocks.ts
+var MAX_BLOCK_TEXT = 2800;
+function buildApprovalRequestMessage(request, actionIds) {
+  const rememberScopes = request.rememberScopes ?? [];
+  const canRemember = rememberScopes.length > 0 || Boolean(request.defaultRememberScope);
+  const text = `Approval required for ${request.tool}`;
+  return {
+    text,
+    blocks: [
+      section(
+        `*Approval required*
+${escapeMrkdwn(request.description || request.tool)}`
+      ),
+      fields([
+        `*Tool*
+${escapeMrkdwn(request.tool)}`,
+        `*Risk*
+${escapeMrkdwn(request.risk)}`
+      ]),
+      section(`*Arguments*
+\`\`\`${truncate(formatArgs(request.args))}\`\`\``),
+      {
+        type: "actions",
+        elements: [
+          button("Allow", "primary", actionIds.approvalAllow, {
+            requestId: request.id
+          }),
+          button("Deny", "danger", actionIds.approvalDeny, {
+            requestId: request.id
+          }),
+          ...canRemember ? [
+            button("Remember", void 0, actionIds.approvalRemember, {
+              requestId: request.id,
+              rememberScope: request.defaultRememberScope ?? rememberScopes[0]
+            })
+          ] : []
+        ]
+      }
+    ]
+  };
+}
+function buildHumanInputRequestMessage(request, actionIds) {
+  const text = request.title || "Input required";
+  const confirmLabel = request.confirmLabel ?? "Submit";
+  const denyLabel = request.denyLabel ?? "Cancel";
+  if (request.kind === "confirm") {
+    return {
+      text,
+      blocks: [
+        section(`*${escapeMrkdwn(text)}*
+${escapeMrkdwn(request.question)}`),
+        {
+          type: "actions",
+          elements: [
+            button(confirmLabel, "primary", actionIds.humanConfirm, {
+              requestId: request.id
+            }),
+            button(denyLabel, "danger", actionIds.humanDeny, {
+              requestId: request.id
+            })
+          ]
+        }
+      ]
+    };
+  }
+  return {
+    text,
+    blocks: [
+      section(`*${escapeMrkdwn(text)}*
+${escapeMrkdwn(request.question)}`),
+      {
+        type: "actions",
+        elements: [
+          button(confirmLabel, "primary", actionIds.humanOpen, {
+            requestId: request.id
+          }),
+          button(denyLabel, "danger", actionIds.humanDeny, {
+            requestId: request.id
+          })
+        ]
+      }
+    ]
+  };
+}
+function buildResolvedMessage(label, resolution) {
+  const text = resolution.kind === "approval" ? resolution.action === "deny" ? "Approval denied" : "Approval granted" : "Input submitted";
+  return {
+    text,
+    blocks: [section(`*${escapeMrkdwn(text)}*
+${escapeMrkdwn(label)}`)]
+  };
+}
+function buildHumanInputModal(request, actionIds) {
+  const title = truncatePlain(request.title || "Input required", 24);
+  const submit = truncatePlain(request.confirmLabel ?? "Submit", 24);
+  const close = truncatePlain(request.denyLabel ?? "Cancel", 24);
+  if (request.kind === "choice") {
+    const options = (request.options ?? []).slice(0, 100).map((option) => ({
+      text: {
+        type: "plain_text",
+        text: truncatePlain(option.label, 75)
+      },
+      value: option.value ?? option.label,
+      ...option.description ? {
+        description: {
+          type: "plain_text",
+          text: truncatePlain(option.description, 75)
+        }
+      } : {}
+    }));
+    return {
+      type: "modal",
+      callback_id: actionIds.humanSubmit,
+      private_metadata: JSON.stringify({ requestId: request.id }),
+      title: { type: "plain_text", text: title },
+      submit: { type: "plain_text", text: submit },
+      close: { type: "plain_text", text: close },
+      blocks: [
+        {
+          type: "input",
+          block_id: "input",
+          label: {
+            type: "plain_text",
+            text: truncatePlain(request.question, 200)
+          },
+          element: {
+            type: request.allowMultiple ? "checkboxes" : "radio_buttons",
+            action_id: "value",
+            options
+          }
+        }
+      ]
+    };
+  }
+  return {
+    type: "modal",
+    callback_id: actionIds.humanSubmit,
+    private_metadata: JSON.stringify({ requestId: request.id }),
+    title: { type: "plain_text", text: title },
+    submit: { type: "plain_text", text: submit },
+    close: { type: "plain_text", text: close },
+    blocks: [
+      {
+        type: "input",
+        block_id: "input",
+        label: {
+          type: "plain_text",
+          text: truncatePlain(request.question, 200)
+        },
+        element: {
+          type: "plain_text_input",
+          action_id: "value",
+          multiline: true,
+          ...request.placeholder ? {
+            placeholder: {
+              type: "plain_text",
+              text: truncatePlain(request.placeholder, 150)
+            }
+          } : {}
+        }
+      }
+    ]
+  };
+}
+function encodeActionValue(payload) {
+  return JSON.stringify(payload);
+}
+function decodeActionValue(value) {
+  if (typeof value !== "string") return {};
+  try {
+    const parsed = JSON.parse(value);
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function button(text, style, actionId, value) {
+  return {
+    type: "button",
+    text: { type: "plain_text", text },
+    action_id: actionId,
+    value: encodeActionValue(value),
+    ...style ? { style } : {}
+  };
+}
+function section(text) {
+  return { type: "section", text: { type: "mrkdwn", text: truncate(text) } };
+}
+function fields(items) {
+  return {
+    type: "section",
+    fields: items.map((text) => ({ type: "mrkdwn", text: truncate(text) }))
+  };
+}
+function formatArgs(args) {
+  if (typeof args === "string") return args;
+  try {
+    return JSON.stringify(args, null, 2);
+  } catch {
+    return String(args);
+  }
+}
+function truncate(value, max = MAX_BLOCK_TEXT) {
+  return value.length <= max ? value : `${value.slice(0, max - 3)}...`;
+}
+function truncatePlain(value, max) {
+  const normalized = value.trim() || "Input";
+  return normalized.length <= max ? normalized : `${normalized.slice(0, max - 3)}...`;
+}
+function escapeMrkdwn(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+
+// src/interactive/store.ts
+function createInMemorySlackInteractiveRequestStore() {
+  const records = /* @__PURE__ */ new Map();
+  return {
+    async get(requestId) {
+      const record = records.get(requestId);
+      return record ? cloneRecord(record) : void 0;
+    },
+    async upsert(record) {
+      const existing = records.get(record.id);
+      if (existing?.status === "resolved") {
+        return cloneRecord(existing);
+      }
+      const next = existing ? {
+        ...existing,
+        ...record,
+        target: record.target ?? existing.target,
+        resolution: record.resolution ?? existing.resolution,
+        updatedAt: nowIso()
+      } : { ...record };
+      records.set(record.id, cloneRecord(next));
+      return cloneRecord(next);
+    },
+    async attachTarget(requestId, target) {
+      const existing = records.get(requestId);
+      if (!existing) return void 0;
+      const next = {
+        ...existing,
+        target: cloneTarget(target),
+        updatedAt: nowIso()
+      };
+      records.set(requestId, cloneRecord(next));
+      return cloneRecord(next);
+    },
+    async resolve(requestId, resolution) {
+      const existing = records.get(requestId);
+      if (!existing) return void 0;
+      if (existing.status === "resolved") {
+        return cloneRecord(existing);
+      }
+      const next = {
+        ...existing,
+        status: "resolved",
+        resolution: cloneResolution(resolution),
+        updatedAt: nowIso()
+      };
+      records.set(requestId, cloneRecord(next));
+      return cloneRecord(next);
+    },
+    async delete(requestId) {
+      records.delete(requestId);
+    }
+  };
+}
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function cloneRecord(record) {
+  return {
+    ...record,
+    request: structuredClone(record.request),
+    ...record.target ? { target: cloneTarget(record.target) } : {},
+    ...record.resolution ? { resolution: cloneResolution(record.resolution) } : {}
+  };
+}
+function cloneTarget(target) {
+  return { ...target };
+}
+function cloneResolution(resolution) {
+  return structuredClone(resolution);
+}
+
+// src/interactive/postgres-store.ts
+var DEFAULT_TABLE = "channel_slack_interactive_requests";
+var DEFAULT_RETENTION_MS = 7 * 24 * 60 * 60 * 1e3;
+var DEFAULT_PRUNE_BATCH_SIZE = 1e3;
+var DEFAULT_PRUNE_INTERVAL_MS = 6 * 60 * 60 * 1e3;
+function createPostgresSlackInteractiveRequestStore({
+  client,
+  connectionString,
+  ensureSchema = true,
+  onPruneError,
+  pruneBatchSize = DEFAULT_PRUNE_BATCH_SIZE,
+  pruneIntervalMs = DEFAULT_PRUNE_INTERVAL_MS,
+  retentionMs = DEFAULT_RETENTION_MS,
+  schema,
+  tableName = DEFAULT_TABLE
+}) {
+  let activeClient = client;
+  let ownsClient = false;
+  let initialized;
+  let pruneTimer;
+  async function getClient() {
+    if (activeClient) {
+      return activeClient;
+    }
+    if (!connectionString) {
+      throw new Error(
+        "connectionString is required when a Postgres Slack interactive request client is not provided"
+      );
+    }
+    const Pool = await importPostgresPoolConstructor();
+    activeClient = new Pool({ connectionString });
+    ownsClient = true;
+    return activeClient;
+  }
+  async function ensureInitialized() {
+    const currentClient = await getClient();
+    initialized ??= initializePostgresSlackInteractiveRequestStore({
+      client: currentClient,
+      ensureSchema,
+      schema,
+      tableName
+    });
+    await initialized;
+    startPruneTimer();
+    return currentClient;
+  }
+  function startPruneTimer() {
+    if (pruneTimer || pruneIntervalMs <= 0) {
+      return;
+    }
+    pruneTimer = setInterval(() => {
+      void prune().catch((error) => {
+        onPruneError?.(error);
+      });
+    }, pruneIntervalMs);
+    pruneTimer.unref?.();
+  }
+  async function prune() {
+    const currentClient = await ensureInitialized();
+    return prunePostgresSlackInteractiveRequestStore({
+      client: currentClient,
+      pruneBatchSize,
+      retentionMs,
+      schema,
+      tableName
+    });
+  }
+  return {
+    async get(requestId) {
+      const currentClient = await ensureInitialized();
+      const result = await currentClient.query(
+        `SELECT * FROM ${qualifiedTableName({
+          schema,
+          tableName
+        })} WHERE id = $1::text LIMIT 1`,
+        [requestId]
+      );
+      return rowToRecord(result.rows[0]);
+    },
+    async upsert(record) {
+      const currentClient = await ensureInitialized();
+      const result = await currentClient.query(
+        `INSERT INTO ${qualifiedTableName({
+          schema,
+          tableName
+        })} (
+          id,
+          kind,
+          request,
+          status,
+          created_at,
+          updated_at,
+          target,
+          resolution
+        )
+        VALUES (
+          $1::text,
+          $2::text,
+          $3::jsonb,
+          $4::text,
+          $5::timestamptz,
+          $6::timestamptz,
+          $7::jsonb,
+          $8::jsonb
+        )
+        ON CONFLICT (id) DO UPDATE SET
+          kind = CASE
+            WHEN ${qualifiedTableName({ schema, tableName })}.status = 'resolved'
+              THEN ${qualifiedTableName({ schema, tableName })}.kind
+            ELSE EXCLUDED.kind
+          END,
+          request = CASE
+            WHEN ${qualifiedTableName({ schema, tableName })}.status = 'resolved'
+              THEN ${qualifiedTableName({ schema, tableName })}.request
+            ELSE EXCLUDED.request
+          END,
+          status = CASE
+            WHEN ${qualifiedTableName({ schema, tableName })}.status = 'resolved'
+              THEN ${qualifiedTableName({ schema, tableName })}.status
+            ELSE EXCLUDED.status
+          END,
+          target = CASE
+            WHEN ${qualifiedTableName({ schema, tableName })}.status = 'resolved'
+              THEN ${qualifiedTableName({ schema, tableName })}.target
+            ELSE COALESCE(EXCLUDED.target, ${qualifiedTableName({
+          schema,
+          tableName
+        })}.target)
+          END,
+          resolution = CASE
+            WHEN ${qualifiedTableName({ schema, tableName })}.status = 'resolved'
+              THEN ${qualifiedTableName({ schema, tableName })}.resolution
+            ELSE COALESCE(EXCLUDED.resolution, ${qualifiedTableName({
+          schema,
+          tableName
+        })}.resolution)
+          END,
+          updated_at = CASE
+            WHEN ${qualifiedTableName({ schema, tableName })}.status = 'resolved'
+              THEN ${qualifiedTableName({ schema, tableName })}.updated_at
+            ELSE now()
+          END
+        RETURNING *`,
+        [
+          record.id,
+          record.kind,
+          JSON.stringify(record.request),
+          record.status,
+          record.createdAt,
+          record.updatedAt,
+          record.target ? JSON.stringify(record.target) : null,
+          record.resolution ? JSON.stringify(record.resolution) : null
+        ]
+      );
+      return requireReturnedRecord(result.rows[0], record.id);
+    },
+    async attachTarget(requestId, target) {
+      const currentClient = await ensureInitialized();
+      const result = await currentClient.query(
+        `UPDATE ${qualifiedTableName({ schema, tableName })}
+        SET target = $2::jsonb, updated_at = now()
+        WHERE id = $1::text
+        RETURNING *`,
+        [requestId, JSON.stringify(target)]
+      );
+      return rowToRecord(result.rows[0]);
+    },
+    async resolve(requestId, resolution) {
+      const currentClient = await ensureInitialized();
+      const result = await currentClient.query(
+        `UPDATE ${qualifiedTableName({ schema, tableName })}
+        SET status = 'resolved',
+          resolution = $2::jsonb,
+          updated_at = now()
+        WHERE id = $1::text AND status <> 'resolved'
+        RETURNING *`,
+        [requestId, JSON.stringify(resolution)]
+      );
+      const resolved = rowToRecord(result.rows[0]);
+      if (resolved) {
+        return resolved;
+      }
+      const existing = await currentClient.query(
+        `SELECT * FROM ${qualifiedTableName({
+          schema,
+          tableName
+        })} WHERE id = $1::text LIMIT 1`,
+        [requestId]
+      );
+      return rowToRecord(existing.rows[0]);
+    },
+    async delete(requestId) {
+      const currentClient = await ensureInitialized();
+      await currentClient.query(
+        `DELETE FROM ${qualifiedTableName({
+          schema,
+          tableName
+        })} WHERE id = $1::text`,
+        [requestId]
+      );
+    },
+    prune,
+    async close() {
+      if (pruneTimer) {
+        clearInterval(pruneTimer);
+        pruneTimer = void 0;
+      }
+      if (ownsClient) {
+        await activeClient?.end?.();
+      }
+    }
+  };
+}
+async function initializePostgresSlackInteractiveRequestStore({
+  client,
+  ensureSchema = true,
+  schema,
+  tableName = DEFAULT_TABLE
+}) {
+  if (schema && ensureSchema) {
+    await client.query(
+      `CREATE SCHEMA IF NOT EXISTS ${quoteIdentifier(schema)}`
+    );
+  }
+  const table = qualifiedTableName({ schema, tableName });
+  await client.query(`
+    CREATE TABLE IF NOT EXISTS ${table} (
+      id text PRIMARY KEY,
+      kind text NOT NULL CHECK (kind IN ('approval', 'human-input')),
+      request jsonb NOT NULL,
+      status text NOT NULL CHECK (status IN ('pending', 'resolved')),
+      target jsonb,
+      resolution jsonb,
+      created_at timestamptz NOT NULL DEFAULT now(),
+      updated_at timestamptz NOT NULL DEFAULT now()
+    )
+  `);
+  const indexPrefix = interactiveIndexPrefix({ schema, tableName });
+  await client.query(
+    `CREATE INDEX IF NOT EXISTS ${quoteIdentifier(
+      `${indexPrefix}_status_updated_idx`
+    )} ON ${table} (status, updated_at DESC)`
+  );
+  await client.query(
+    `CREATE INDEX IF NOT EXISTS ${quoteIdentifier(
+      `${indexPrefix}_updated_idx`
+    )} ON ${table} (updated_at DESC)`
+  );
+}
+async function prunePostgresSlackInteractiveRequestStore({
+  client,
+  pruneBatchSize = DEFAULT_PRUNE_BATCH_SIZE,
+  retentionMs = DEFAULT_RETENTION_MS,
+  schema,
+  tableName = DEFAULT_TABLE
+}) {
+  if (retentionMs <= 0) {
+    return { deleted: 0 };
+  }
+  const batchSize = Math.max(1, Math.floor(pruneBatchSize));
+  const result = await client.query(
+    `WITH expired AS (
+      SELECT id
+      FROM ${qualifiedTableName({ schema, tableName })}
+      WHERE updated_at < now() - ($1::bigint * interval '1 millisecond')
+      ORDER BY updated_at ASC
+      LIMIT $2::integer
+    )
+    DELETE FROM ${qualifiedTableName({ schema, tableName })} target
+    USING expired
+    WHERE target.id = expired.id`,
+    [Math.max(1, Math.floor(retentionMs)), batchSize]
+  );
+  return { deleted: result.rowCount ?? 0 };
+}
+function rowToRecord(row) {
+  if (!row) return void 0;
+  return cloneRecord({
+    id: row.id,
+    kind: row.kind,
+    request: readJsonValue(
+      row.request
+    ),
+    status: row.status,
+    createdAt: toIsoString(row.created_at),
+    updatedAt: toIsoString(row.updated_at),
+    ...row.target ? {
+      target: readJsonValue(
+        row.target
+      )
+    } : {},
+    ...row.resolution ? {
+      resolution: readJsonValue(
+        row.resolution
+      )
+    } : {}
+  });
+}
+function requireReturnedRecord(row, requestId) {
+  const record = rowToRecord(row);
+  if (!record) {
+    throw new Error(
+      `Postgres Slack interactive request store did not return request ${requestId}.`
+    );
+  }
+  return record;
+}
+function readJsonValue(value) {
+  if (typeof value === "string") {
+    return JSON.parse(value);
+  }
+  return value;
+}
+function toIsoString(value) {
+  return value instanceof Date ? value.toISOString() : new Date(value).toISOString();
+}
+function qualifiedTableName({
+  schema,
+  tableName
+}) {
+  return schema ? `${quoteIdentifier(schema)}.${quoteIdentifier(tableName)}` : quoteIdentifier(tableName);
+}
+function quoteIdentifier(value) {
+  return `"${value.replace(/"/g, '""')}"`;
+}
+function interactiveIndexPrefix({
+  schema,
+  tableName
+}) {
+  const raw = [schema, tableName].filter(Boolean).join("_");
+  return raw.replace(/[^A-Za-z0-9_]+/g, "_").replace(/^_+|_+$/g, "").slice(0, 40) || "channel_slack_interactive";
+}
+async function importPostgresPoolConstructor() {
+  const dynamicImport = new Function(
+    "specifier",
+    "return import(specifier)"
+  );
+  try {
+    const pg = await dynamicImport("pg");
+    return pg.Pool;
+  } catch (error) {
+    throw new Error(
+      `The "pg" package is required when using connectionString with createPostgresSlackInteractiveRequestStore. Install pg or pass a client. ${formatImportError(
+        error
+      )}`
+    );
+  }
+}
+function formatImportError(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+export {
+  buildApprovalRequestMessage,
+  buildHumanInputModal,
+  buildHumanInputRequestMessage,
+  buildResolvedMessage,
+  cloneRecord,
+  createInMemorySlackInteractiveRequestStore,
+  createPostgresSlackInteractiveRequestStore,
+  decodeActionValue,
+  encodeActionValue,
+  initializePostgresSlackInteractiveRequestStore,
+  nowIso,
+  prunePostgresSlackInteractiveRequestStore
+};

package/dist/interactive-CbKYkkc_.d.ts

@@ -0,0 +1,46 @@
+import { S as SlackActivityInfo, b as SlackUserIdentity } from './activity-ByrD9Ftr.js';
+
+/**
+ * Transport-neutral interactive request contracts.
+ *
+ * These types let callers delegate approval and human-input requests to a
+ * Slack-specific renderer without importing Bolt or Web API types into
+ * `shared/`.
+ */
+
+type SlackInteractiveRequestKind = "approval" | "human-input";
+interface SlackApprovalRequest {
+    id: string;
+}
+interface SlackHumanInputRequest {
+    id: string;
+}
+type SlackInteractiveRequest = SlackApprovalRequest | SlackHumanInputRequest;
+interface SlackInteractiveMessageRef {
+    channel: string;
+    ts: string;
+}
+interface SlackInteractiveMessage {
+    text: string;
+    blocks?: unknown[];
+}
+interface SlackInteractiveResponder {
+    postMessage(message: SlackInteractiveMessage): Promise<SlackInteractiveMessageRef>;
+    updateMessage(ref: SlackInteractiveMessageRef, message: SlackInteractiveMessage): Promise<void>;
+}
+interface SlackInteractiveRequestBaseContext {
+    kind: SlackInteractiveRequestKind;
+    request: SlackInteractiveRequest;
+    fallbackText: string;
+}
+interface SlackInteractiveRequestContext extends SlackInteractiveRequestBaseContext {
+    slackActivity: SlackActivityInfo;
+    user: SlackUserIdentity;
+    sessionId: string;
+    message: string;
+    responder: SlackInteractiveResponder;
+}
+type SlackInteractiveRequestHandler = (context: SlackInteractiveRequestContext) => boolean | void | Promise<boolean | void>;
+type SlackEventInteractiveRequestHandler = (context: SlackInteractiveRequestBaseContext) => boolean | void | Promise<boolean | void>;
+
+export type { SlackApprovalRequest as S, SlackEventInteractiveRequestHandler as a, SlackHumanInputRequest as b, SlackInteractiveMessage as c, SlackInteractiveMessageRef as d, SlackInteractiveRequest as e, SlackInteractiveRequestBaseContext as f, SlackInteractiveRequestContext as g, SlackInteractiveRequestHandler as h, SlackInteractiveRequestKind as i, SlackInteractiveResponder as j };

package/dist/responses/index.d.ts

@@ -0,0 +1,74 @@
+import { d as SlackArtifactClient } from '../types-C8nkPuD4.js';
+
+/**
+ * Slack response-sink contracts consumed by the event bridge.
+ *
+ * The adapter constructs a `SlackResponseSink` from the Bolt `say` function
+ * and `WebClient` instance available in each handler. Keeping the sink
+ * interface separate makes the bridge testable without a live Slack
+ * connection.
+ */
+
+type SlackStreamTaskStatus = "pending" | "in_progress" | "complete" | "error";
+type SlackStreamChunk = {
+    type: "markdown_text";
+    text: string;
+} | {
+    type: "plan_update";
+    title: string;
+} | {
+    type: "task_update";
+    id: string;
+    title: string;
+    status: SlackStreamTaskStatus;
+    details?: string;
+    output?: string;
+};
+interface SlackChatStream {
+    append(args: {
+        markdown_text?: string;
+        chunks?: SlackStreamChunk[];
+    }): Promise<unknown>;
+    stop(args?: {
+        markdown_text?: string;
+        chunks?: SlackStreamChunk[];
+    }): Promise<unknown>;
+}
+/**
+ * Minimal Slack posting interface consumed by the event bridge.
+ */
+interface SlackArtifactPublicationTarget {
+    channelId: string;
+    threadTs?: string;
+}
+interface SlackResponseSink {
+    /**
+     * Slack Web API surface used by optional artifact publishers.
+     */
+    artifactClient?: SlackArtifactClient;
+    /**
+     * Channel/thread target used by optional artifact publishers.
+     */
+    artifactTarget?: SlackArtifactPublicationTarget;
+    /**
+     * Post a new message to the channel / thread.
+     * Returns the channel ID and message timestamp needed for updates.
+     */
+    postMessage(text: string): Promise<{
+        channel: string;
+        ts: string;
+    }>;
+    /**
+     * Update an existing message by channel + ts.
+     */
+    updateMessage(channel: string, ts: string, text: string): Promise<void>;
+    /**
+     * Create a native Slack chat stream. Required when `streamingMode` is
+     * `"chat-stream"`.
+     */
+    createChatStream?(options: {
+        bufferSize: number;
+    }): SlackChatStream;
+}
+
+export type { SlackArtifactPublicationTarget, SlackChatStream, SlackResponseSink, SlackStreamChunk, SlackStreamTaskStatus };

package/dist/types-C8nkPuD4.d.ts

@@ -0,0 +1,111 @@
+type SlackArtifactPublishMethod = "message" | "file" | "canvas";
+type SlackArtifactBinaryData = string | Uint8Array | ArrayBuffer;
+interface SlackArtifactBase {
+    kind: string;
+    title: string;
+    summary?: string;
+    metadata?: Record<string, unknown>;
+}
+interface SlackTextArtifact extends SlackArtifactBase {
+    kind: "text";
+    text: string;
+    filename?: string;
+    mimeType?: string;
+    publishAs?: "message" | "file";
+}
+interface SlackFileArtifact extends SlackArtifactBase {
+    kind: "file";
+    filename: string;
+    data?: SlackArtifactBinaryData;
+    filePath?: string;
+    mimeType?: string;
+    initialComment?: string;
+}
+interface SlackImageArtifact extends SlackArtifactBase {
+    kind: "image";
+    filename: string;
+    altText: string;
+    data?: SlackArtifactBinaryData;
+    filePath?: string;
+    initialComment?: string;
+}
+interface SlackLinkArtifact extends SlackArtifactBase {
+    kind: "link";
+    url: string;
+}
+interface SlackCanvasArtifact extends SlackArtifactBase {
+    kind: "canvas";
+    markdown: string;
+    /**
+     * When set, updates an existing canvas instead of creating one.
+     */
+    canvasId?: string;
+    /**
+     * Create a channel canvas when a channel is available.
+     *
+     * @default true
+     */
+    channelCanvas?: boolean;
+}
+type SlackArtifact = SlackTextArtifact | SlackFileArtifact | SlackImageArtifact | SlackLinkArtifact | SlackCanvasArtifact;
+interface SlackArtifactPostMessageResponse {
+    ok?: boolean;
+    channel?: string;
+    ts?: string;
+    [key: string]: unknown;
+}
+interface SlackArtifactFileUploadResponse {
+    ok?: boolean;
+    file?: {
+        id?: string;
+        [key: string]: unknown;
+    };
+    files?: Array<{
+        id?: string;
+        [key: string]: unknown;
+    }>;
+    [key: string]: unknown;
+}
+interface SlackArtifactCanvasResponse {
+    ok?: boolean;
+    canvas_id?: string;
+    [key: string]: unknown;
+}
+interface SlackArtifactClient {
+    chat?: {
+        postMessage(args: Record<string, unknown>): Promise<SlackArtifactPostMessageResponse>;
+    };
+    files?: {
+        uploadV2(args: Record<string, unknown>): Promise<SlackArtifactFileUploadResponse>;
+    };
+    canvases?: {
+        create(args?: Record<string, unknown>): Promise<SlackArtifactCanvasResponse>;
+        edit?(args: Record<string, unknown>): Promise<SlackArtifactCanvasResponse>;
+    };
+    conversations?: {
+        canvases?: {
+            create(args: Record<string, unknown>): Promise<SlackArtifactCanvasResponse>;
+        };
+    };
+}
+interface PublishSlackArtifactOptions {
+    client: SlackArtifactClient;
+    artifact: SlackArtifact;
+    channelId?: string;
+    threadTs?: string;
+    token?: string;
+    unfurlLinks?: boolean;
+    unfurlMedia?: boolean;
+}
+interface SlackArtifactPublication {
+    artifact: SlackArtifact;
+    method: SlackArtifactPublishMethod;
+    response: unknown;
+    channelId?: string;
+    threadTs?: string;
+    messageTs?: string;
+    fileId?: string;
+    canvasId?: string;
+}
+
+export type { PublishSlackArtifactOptions as P, SlackArtifact as S, SlackArtifactBase as a, SlackArtifactBinaryData as b, SlackArtifactCanvasResponse as c, SlackArtifactClient as d, SlackArtifactFileUploadResponse as e, SlackArtifactPostMessageResponse as f, SlackArtifactPublication as g, SlackArtifactPublishMethod as h, SlackCanvasArtifact as i, SlackFileArtifact as j, SlackImageArtifact as k, SlackLinkArtifact as l, SlackTextArtifact as m };

package/docs/reference/channel-slack-boundary.md

@@ -24,6 +24,9 @@ contracts.
 - User profile and mention helpers.
 - Target parsing and resolution.
 - Feedback blocks and action handler.
+- Slack response sink and chat stream contracts for runtime adapters.
+- Slack interactive request Block Kit/modal builders and in-memory/Postgres
+  stores.
 - Slack message policy resolver and in-memory/Postgres state stores.
 - Supplemental history reader, context loader, and visibility policy.
 - Assistant message parser and thread-context store.
@@ -33,8 +36,8 @@ contracts.
 - Agent runtime execution.
 - Agent-runtime scopes and context-fragment middleware.
 - Runtime-specific mapping from Slack entrypoints into an agent turn.
-- Agent event stream rendering.
-- Agent-specific approval and human-input request contracts.
+- Agent event stream rendering and runtime-specific response orchestration.
+- Agent-specific approval and human-input controllers.
 - Product prompts, tools, audit policy, and deployment policy.
 
 Those pieces belong in runtime-specific adapters or product applications.

package/docs/reference/exports.md

@@ -8,9 +8,11 @@ keep application code close to the package boundary it uses.
 | `@cuylabs/channel-slack/core`              | no Slack SDK runtime imports                                                    | Transport-neutral parsing, formatting, types, sessions, turn context     |
 | `@cuylabs/channel-slack/policy`            | `pg` only when using connection-string Postgres state                           | Message admission and in-memory/Postgres policy state                    |
 | `@cuylabs/channel-slack/history`           | `@slack/web-api` types                                                          | History reader accepts a Slack WebClient or minimal conversations client |
+| `@cuylabs/channel-slack/interactive`       | `@slack/types`; `pg` only when using connection-string Postgres storage         | Slack interactive Block Kit/modal builders and request stores            |
 | `@cuylabs/channel-slack/app-home`          | `@slack/bolt`, `@slack/types`                                                   | Slack App Home registration helper                                       |
 | `@cuylabs/channel-slack/artifacts`         | no Slack SDK runtime imports; requires a Web API-like client at call time       | Text, file, image, link, and Canvas artifact publishing                  |
 | `@cuylabs/channel-slack/auth`              | no Slack SDK runtime imports; `pg` is not required                              | Auth option types, auth resolution, OAuth installation stores            |
+| `@cuylabs/channel-slack/responses`         | no Slack SDK runtime imports                                                    | Slack response sink and chat stream contracts for runtime adapters       |
 | `@cuylabs/channel-slack/transports`        | `@slack/bolt`, `express`; `pg` only when using connection-string Postgres locks | HTTP and Socket Mode transport helpers                                   |
 | `@cuylabs/channel-slack/transports/http`   | `@slack/bolt`, `express`                                                        | HTTP Events API Bolt app factory                                         |
 | `@cuylabs/channel-slack/transports/socket` | `@slack/bolt`; `pg` only when using connection-string Postgres locks            | Socket Mode app factory, runtime guard, process/Postgres locks           |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cuylabs/channel-slack",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "description": "Agent-runtime-agnostic Slack channel primitives for AI agents",
   "type": "module",
   "main": "./dist/index.js",
@@ -56,11 +56,21 @@
       "import": "./dist/history/index.js",
       "default": "./dist/history/index.js"
     },
+    "./interactive": {
+      "types": "./dist/interactive/index.d.ts",
+      "import": "./dist/interactive/index.js",
+      "default": "./dist/interactive/index.js"
+    },
     "./policy": {
       "types": "./dist/policy/index.d.ts",
       "import": "./dist/policy/index.js",
       "default": "./dist/policy/index.js"
     },
+    "./responses": {
+      "types": "./dist/responses/index.d.ts",
+      "import": "./dist/responses/index.js",
+      "default": "./dist/responses/index.js"
+    },
     "./setup": {
       "types": "./dist/setup/index.d.ts",
       "import": "./dist/setup/index.js",
@@ -153,9 +163,9 @@
     "node": ">=20"
   },
   "scripts": {
-    "build": "tsup src/index.ts src/app-home.ts src/artifacts/index.ts src/core.ts src/assistant/index.ts src/auth/index.ts src/diagnostics/index.ts src/entrypoints/index.ts src/feedback/index.ts src/history/index.ts src/policy/index.ts src/setup/index.ts src/targets/index.ts src/turn-controls/index.ts src/transports/index.ts src/transports/http/index.ts src/transports/socket/index.ts src/users/index.ts src/views/index.ts --format esm --dts --clean",
+    "build": "tsup src/index.ts src/app-home.ts src/artifacts/index.ts src/core.ts src/assistant/index.ts src/auth/index.ts src/diagnostics/index.ts src/entrypoints/index.ts src/feedback/index.ts src/history/index.ts src/interactive/index.ts src/policy/index.ts src/responses/index.ts src/setup/index.ts src/targets/index.ts src/turn-controls/index.ts src/transports/index.ts src/transports/http/index.ts src/transports/socket/index.ts src/users/index.ts src/views/index.ts --format esm --dts --clean",
     "clean": "rm -rf dist",
-    "dev": "tsup src/index.ts src/app-home.ts src/artifacts/index.ts src/core.ts src/assistant/index.ts src/auth/index.ts src/diagnostics/index.ts src/entrypoints/index.ts src/feedback/index.ts src/history/index.ts src/policy/index.ts src/setup/index.ts src/targets/index.ts src/turn-controls/index.ts src/transports/index.ts src/transports/http/index.ts src/transports/socket/index.ts src/users/index.ts src/views/index.ts --format esm --dts --watch",
+    "dev": "tsup src/index.ts src/app-home.ts src/artifacts/index.ts src/core.ts src/assistant/index.ts src/auth/index.ts src/diagnostics/index.ts src/entrypoints/index.ts src/feedback/index.ts src/history/index.ts src/interactive/index.ts src/policy/index.ts src/responses/index.ts src/setup/index.ts src/targets/index.ts src/turn-controls/index.ts src/transports/index.ts src/transports/http/index.ts src/transports/socket/index.ts src/users/index.ts src/views/index.ts --format esm --dts --watch",
     "lint": "eslint \"src/**/*.{ts,tsx}\" \"tests/**/*.{ts,tsx}\" --max-warnings=0",
     "test": "vitest run",
     "test:watch": "vitest",