@cuylabs/channel-slack 0.7.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/chunk-3KP3CBCC.js

@@ -0,0 +1,175 @@
+// src/turn-controls/block.ts
+var SLACK_TURN_CANCEL_ACTION_ID = "agent_turn_cancel";
+function createSlackTurnCancelMessage(options) {
+  const actionId = resolveSlackTurnCancelActionId(options.actionId);
+  const controlId = options.controlId.trim();
+  if (!controlId) {
+    throw new Error(
+      "createSlackTurnCancelMessage: controlId must be a non-empty string"
+    );
+  }
+  const text = (options.messageText ?? "Request controls").trim();
+  if (!text) {
+    throw new Error(
+      "createSlackTurnCancelMessage: messageText must be a non-empty string"
+    );
+  }
+  const buttonText = (options.buttonText ?? "Cancel").trim();
+  if (!buttonText) {
+    throw new Error(
+      "createSlackTurnCancelMessage: buttonText must be a non-empty string"
+    );
+  }
+  const value = encodeSlackTurnCancelButtonValue({
+    action: "cancel",
+    controlId,
+    ...options.sessionId ? { sessionId: options.sessionId } : {},
+    ...options.turnId ? { turnId: options.turnId } : {}
+  });
+  return {
+    text,
+    blocks: [
+      {
+        type: "section",
+        text: { type: "mrkdwn", text }
+      },
+      {
+        type: "actions",
+        elements: [
+          {
+            type: "button",
+            action_id: actionId,
+            text: { type: "plain_text", text: buttonText },
+            accessibility_label: buttonText,
+            style: "danger",
+            value
+          }
+        ]
+      }
+    ]
+  };
+}
+function encodeSlackTurnCancelButtonValue(value) {
+  return JSON.stringify(value);
+}
+function decodeSlackTurnCancelButtonValue(rawValue) {
+  if (typeof rawValue !== "string" || !rawValue.trim()) {
+    return void 0;
+  }
+  try {
+    const parsed = JSON.parse(rawValue);
+    const controlId = parseOptionalString(parsed.controlId);
+    if (parsed.action !== "cancel" || !controlId) {
+      return void 0;
+    }
+    const sessionId = parseOptionalString(parsed.sessionId);
+    const turnId = parseOptionalString(parsed.turnId);
+    return {
+      action: "cancel",
+      controlId,
+      ...sessionId ? { sessionId } : {},
+      ...turnId ? { turnId } : {}
+    };
+  } catch {
+    return void 0;
+  }
+}
+function parseOptionalString(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  return trimmed || void 0;
+}
+function resolveSlackTurnCancelActionId(actionId) {
+  const resolved = (actionId ?? SLACK_TURN_CANCEL_ACTION_ID).trim();
+  if (!resolved) {
+    throw new Error("Slack turn cancel action id cannot be empty.");
+  }
+  return resolved;
+}
+
+// src/turn-controls/action.ts
+function registerSlackTurnCancelAction(app, options) {
+  const actionId = resolveSlackTurnCancelActionId(options.actionId);
+  app.action(
+    actionId,
+    // Bolt's action args are structurally stable, but not exported as one
+    // concise public type across all action element variants.
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    async ({ ack, body, client, logger }) => {
+      try {
+        const ackFn = ack;
+        await ackFn();
+        if (body?.type !== "block_actions" || !Array.isArray(body.actions) || body.actions.length === 0) {
+          return;
+        }
+        const action = body.actions[0];
+        if (action?.type !== "button") {
+          return;
+        }
+        const value = decodeSlackTurnCancelButtonValue(action.value);
+        if (!value) {
+          return;
+        }
+        const channelId = body.channel?.id ?? body.container?.channel_id;
+        const userId = body.user?.id;
+        const messageTs = body.message?.ts ?? body.container?.message_ts;
+        const threadTs = body.message?.thread_ts ?? body.container?.thread_ts;
+        const teamId = body.team?.id;
+        const triggerId = typeof body.trigger_id === "string" ? body.trigger_id : void 0;
+        if (!channelId || !userId || !messageTs) {
+          return;
+        }
+        const acknowledgeEphemeral = async (text) => {
+          await client.chat.postEphemeral({
+            channel: channelId,
+            user: userId,
+            ...threadTs ? { thread_ts: threadTs } : { thread_ts: messageTs },
+            text
+          });
+        };
+        const deleteMessage = async () => {
+          await client.chat.delete({
+            channel: channelId,
+            ts: messageTs
+          });
+        };
+        const updateMessage = async (message) => {
+          await client.chat.update({
+            channel: channelId,
+            ts: messageTs,
+            text: message.text,
+            ...message.blocks ? { blocks: message.blocks } : {}
+          });
+        };
+        await options.onCancel({
+          ...value,
+          channelId,
+          userId,
+          messageTs,
+          ...threadTs ? { threadTs } : {},
+          ...teamId ? { teamId } : {},
+          ...triggerId ? { triggerId } : {},
+          acknowledgeEphemeral,
+          deleteMessage,
+          updateMessage
+        });
+      } catch (error) {
+        logger?.error?.(
+          `[channel-slack] turn cancel action failed: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  return { actionId };
+}
+
+export {
+  SLACK_TURN_CANCEL_ACTION_ID,
+  createSlackTurnCancelMessage,
+  encodeSlackTurnCancelButtonValue,
+  decodeSlackTurnCancelButtonValue,
+  resolveSlackTurnCancelActionId,
+  registerSlackTurnCancelAction
+};

package/dist/core.d.ts

@@ -1,4 +1,8 @@
 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';
 
 /**
  * Slack auth context — credentials and identifiers resolved from the inbound
@@ -175,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.
@@ -422,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/core.js

@@ -3,7 +3,15 @@ import {
   formatSlackAttributedFollowUp,
   resolveThreadAwareSlackSessionId,
   runWithSlackTurnContext
-} from "./chunk-X4WBBBYM.js";
+} from "./chunk-ISOMBQXE.js";
+import {
+  SLACK_TURN_CANCEL_ACTION_ID,
+  createSlackTurnCancelMessage,
+  decodeSlackTurnCancelButtonValue,
+  encodeSlackTurnCancelButtonValue,
+  registerSlackTurnCancelAction,
+  resolveSlackTurnCancelActionId
+} from "./chunk-3KP3CBCC.js";
 import {
   markdownToSlackMrkdwn,
   resolveSlackMessageFormatter
@@ -24,7 +32,11 @@ import {
   stripLeadingMentions
 } from "./chunk-FPCE5V5Y.js";
 export {
+  SLACK_TURN_CANCEL_ACTION_ID,
+  createSlackTurnCancelMessage,
   currentSlackTurnContext,
+  decodeSlackTurnCancelButtonValue,
+  encodeSlackTurnCancelButtonValue,
   extractSlackActionToken,
   extractSlackAttachmentsText,
   extractSlackAuthContext,
@@ -36,8 +48,10 @@ export {
   markdownToSlackMrkdwn,
   parseSlackMentionActivity,
   parseSlackMessageActivity,
+  registerSlackTurnCancelAction,
   resolveSlackChannelType,
   resolveSlackMessageFormatter,
+  resolveSlackTurnCancelActionId,
   resolveThreadAwareSlackSessionId,
   runWithSlackTurnContext,
   stripLeadingMentions

package/dist/index.d.ts

@@ -1,4 +1,8 @@
 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';
+import '@slack/types';
+import '@slack/bolt';

package/dist/index.js

@@ -20,7 +20,15 @@ import {
   formatSlackAttributedFollowUp,
   resolveThreadAwareSlackSessionId,
   runWithSlackTurnContext
-} from "./chunk-X4WBBBYM.js";
+} from "./chunk-ISOMBQXE.js";
+import {
+  SLACK_TURN_CANCEL_ACTION_ID,
+  createSlackTurnCancelMessage,
+  decodeSlackTurnCancelButtonValue,
+  encodeSlackTurnCancelButtonValue,
+  registerSlackTurnCancelAction,
+  resolveSlackTurnCancelActionId
+} from "./chunk-3KP3CBCC.js";
 import {
   markdownToSlackMrkdwn,
   resolveSlackMessageFormatter
@@ -41,6 +49,7 @@ import {
   stripLeadingMentions
 } from "./chunk-FPCE5V5Y.js";
 export {
+  SLACK_TURN_CANCEL_ACTION_ID,
   createAsyncSlackMessagePolicyResolver,
   createAsyncSlackThreadAwareMessagePolicyResolver,
   createInMemorySlackMessagePolicyStateStore,
@@ -50,7 +59,10 @@ export {
   createSlackMessagePolicyMessageKey,
   createSlackMessagePolicyResolver,
   createSlackMessagePolicyThreadKey,
+  createSlackTurnCancelMessage,
   currentSlackTurnContext,
+  decodeSlackTurnCancelButtonValue,
+  encodeSlackTurnCancelButtonValue,
   extractSlackActionToken,
   extractSlackAttachmentsText,
   extractSlackAuthContext,
@@ -66,9 +78,11 @@ export {
   parseSlackMessageActivity,
   prunePostgresSlackMessagePolicyState,
   prunePostgresSlackThreadParticipationState,
+  registerSlackTurnCancelAction,
   resolveSlackChannelType,
   resolveSlackMessageFormatter,
   resolveSlackThreadParticipationEligibility,
+  resolveSlackTurnCancelActionId,
   resolveThreadAwareSlackSessionId,
   runWithSlackTurnContext,
   shouldRegisterSlackPassiveChannelMessages,

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 };