@cuylabs/channel-slack-agent-core 0.8.0 → 0.9.0

package/README.md

@@ -8,7 +8,8 @@ surfaces for Express Events API, Socket Mode, Slack Assistant, app mentions,
 DMs, feedback, approvals, or human input.
 
 Generic Slack mechanics such as parsing, policy, history, setup, auth, targets,
-users, entrypoints, artifacts, and transports live in `@cuylabs/channel-slack`.
+users, entrypoints, artifacts, interactive stores/builders, response sinks, and
+transports live in `@cuylabs/channel-slack`.
 
 ## Install
 
@@ -22,7 +23,8 @@ Install Slack peer dependencies for the surfaces you use:
 npm install @slack/bolt @slack/web-api express
 ```
 
-Postgres-backed interactive request storage lazy-loads `pg` when you pass a
+Postgres-backed interactive request storage lives in
+`@cuylabs/channel-slack/interactive` and lazy-loads `pg` when you pass a
 connection string. Install `pg` only when your application uses that helper
 without injecting its own client.
 

package/dist/adapter/index.d.ts

@@ -1,12 +1,13 @@
-export { c as createSlackChannelAdapter } from '../adapter-B3CI611y.js';
-import { a as SlackChannelOptions } from '../types-CRWzJB5G.js';
-export { S as SlackChannelAdapter, b as SlackSessionStrategy, c as SlackStreamingMode, d as SlackToolStartEvent } from '../types-CRWzJB5G.js';
+export { c as createSlackChannelAdapter } from '../adapter-vbqtraAr.js';
+import { a as SlackChannelOptions } from '../types-BeGPexio.js';
+export { S as SlackChannelAdapter, b as SlackSessionStrategy, c as SlackStreamingMode, d as SlackToolStartEvent } from '../types-BeGPexio.js';
 import { SlackActivityInfo } from '@cuylabs/channel-slack/core';
 import '@cuylabs/agent-core';
-import '../options-BcDReOJv.js';
+import '../options-CGUfVStV.js';
 import '../artifacts/index.js';
 import '@cuylabs/channel-slack/artifacts';
-import '../interactive-o_NZb-Xg.js';
+import '../interactive-BigrPKnu.js';
+import '@cuylabs/channel-slack/interactive';
 
 /**
  * Session mapping — Slack activity info to agent-core session IDs.

package/dist/adapter/index.js

@@ -1,8 +1,8 @@
 import {
   createSlackChannelAdapter,
   createSlackSessionMap
-} from "../chunk-FQWFB54C.js";
-import "../chunk-TMADMHBN.js";
+} from "../chunk-XA7U3GRN.js";
+import "../chunk-VBGQD6JT.js";
 export {
   createSlackChannelAdapter,
   createSlackSessionMap

package/dist/{adapter-B3CI611y.d.ts → adapter-vbqtraAr.d.ts}

@@ -1,4 +1,4 @@
-import { a as SlackChannelOptions, S as SlackChannelAdapter } from './types-CRWzJB5G.js';
+import { a as SlackChannelOptions, S as SlackChannelAdapter } from './types-BeGPexio.js';
 
 /**
  * Slack Channel Adapter

package/dist/app-surface.d.ts

@@ -1,14 +1,15 @@
 import { AgentTurnSource, Logger } from '@cuylabs/agent-core';
 import { App } from '@slack/bolt';
 import { WebClient } from '@slack/web-api';
-import { C as CreateSlackAssistantBridgeOptions, d as SlackAssistantFeedbackConfig, S as SlackAssistantBridge } from './options-C7-VXmhD.js';
-import { a as SlackChannelOptions } from './types-CRWzJB5G.js';
+import { C as CreateSlackAssistantBridgeOptions, d as SlackAssistantFeedbackConfig, S as SlackAssistantBridge } from './options-ByNm2o89.js';
+import { a as SlackChannelOptions } from './types-BeGPexio.js';
 import { SlackTurnRequestContext, SlackAssistantUtilities, SlackTurnPreparation } from '@cuylabs/channel-slack/core';
 import { SlackFeedbackHandler } from '@cuylabs/channel-slack/feedback';
-import { c as SlackInteractiveController } from './types-Crpil4kb.js';
+import { a as SlackInteractiveController } from './types-Bz4OYEAV.js';
 import { d as SlackAgentViewWorkflowController } from './types-CiwGU6zC.js';
-import './interactive-o_NZb-Xg.js';
-import './options-BcDReOJv.js';
+import './interactive-BigrPKnu.js';
+import '@cuylabs/channel-slack/interactive';
+import './options-CGUfVStV.js';
 import './artifacts/index.js';
 import '@cuylabs/channel-slack/artifacts';
 import '@cuylabs/channel-slack/assistant';

package/dist/app-surface.js

@@ -1,10 +1,10 @@
 import {
   installSlackAgentAppSurface
-} from "./chunk-6T6N4MRK.js";
-import "./chunk-7YZWCSML.js";
+} from "./chunk-GKZRDNEB.js";
+import "./chunk-FJP6ZFUB.js";
 import "./chunk-ELR6MQD7.js";
-import "./chunk-FQWFB54C.js";
-import "./chunk-TMADMHBN.js";
+import "./chunk-XA7U3GRN.js";
+import "./chunk-VBGQD6JT.js";
 export {
   installSlackAgentAppSurface
 };

package/dist/app.d.ts

@@ -5,17 +5,18 @@ import { CreateSlackBoltAppOptions } from '@cuylabs/channel-slack/transports/htt
 import { SlackDirectAuthOptions, SlackDirectAuthMode } from '@cuylabs/channel-slack/auth';
 import { SlackAgentAppSurfaceOptions } from './app-surface.js';
 export { MountSlackAgentAppTurnRequestContext } from './app-surface.js';
-import { S as SlackAssistantBridge } from './options-C7-VXmhD.js';
+import { S as SlackAssistantBridge } from './options-ByNm2o89.js';
 import '@cuylabs/agent-core';
 import '@slack/web-api';
-import './types-CRWzJB5G.js';
+import './types-BeGPexio.js';
 import '@cuylabs/channel-slack/core';
-import './options-BcDReOJv.js';
+import './options-CGUfVStV.js';
 import './artifacts/index.js';
 import '@cuylabs/channel-slack/artifacts';
-import './interactive-o_NZb-Xg.js';
+import './interactive-BigrPKnu.js';
+import '@cuylabs/channel-slack/interactive';
 import '@cuylabs/channel-slack/feedback';
-import './types-Crpil4kb.js';
+import './types-Bz4OYEAV.js';
 import './types-CiwGU6zC.js';
 import '@cuylabs/channel-slack/views';
 import '@cuylabs/channel-slack/assistant';

package/dist/app.js

@@ -1,11 +1,11 @@
 import {
   mountSlackAgentApp
-} from "./chunk-236WN6JD.js";
-import "./chunk-6T6N4MRK.js";
-import "./chunk-7YZWCSML.js";
+} from "./chunk-KAEZPS3U.js";
+import "./chunk-GKZRDNEB.js";
+import "./chunk-FJP6ZFUB.js";
 import "./chunk-ELR6MQD7.js";
-import "./chunk-FQWFB54C.js";
-import "./chunk-TMADMHBN.js";
+import "./chunk-XA7U3GRN.js";
+import "./chunk-VBGQD6JT.js";
 export {
   mountSlackAgentApp
 };

package/dist/assistant/index.d.ts

@@ -1,12 +1,13 @@
-import { C as CreateSlackAssistantBridgeOptions, S as SlackAssistantBridge } from '../options-C7-VXmhD.js';
-export { A as AssistantLifecycleArgs, a as AssistantThreadStartedArgs, M as MaybePromise, b as SlackAssistantCancelControlOptions, c as SlackAssistantCancelControlVisibleWhen, d as SlackAssistantFeedbackConfig, e as SlackAssistantSessionStrategy, f as SlackAssistantStatusContext, g as SlackAssistantThreadContextStoreLike, h as SlackAssistantThreadStartedContext, i as SlackAssistantTurnCancelContext, j as SlackAssistantTurnControlsOptions, k as SlackAssistantTurnPreparation, l as SlackAssistantUserMessageContext, r as resolveAssistantSessionId } from '../options-C7-VXmhD.js';
+import { C as CreateSlackAssistantBridgeOptions, S as SlackAssistantBridge } from '../options-ByNm2o89.js';
+export { A as AssistantLifecycleArgs, a as AssistantThreadStartedArgs, M as MaybePromise, b as SlackAssistantCancelControlOptions, c as SlackAssistantCancelControlVisibleWhen, d as SlackAssistantFeedbackConfig, e as SlackAssistantSessionStrategy, f as SlackAssistantStatusContext, g as SlackAssistantThreadContextStoreLike, h as SlackAssistantThreadStartedContext, i as SlackAssistantTurnCancelContext, j as SlackAssistantTurnControlsOptions, k as SlackAssistantTurnPreparation, l as SlackAssistantUserMessageContext, r as resolveAssistantSessionId } from '../options-ByNm2o89.js';
 export { ParsedAssistantUserMessage, createSlackAssistantThreadContextStore, parseSlackMessageActivityFromMessageEvent } from '@cuylabs/channel-slack/assistant';
 import '@cuylabs/agent-core';
 import '@slack/bolt';
 import '@slack/web-api';
 import '@cuylabs/channel-slack/core';
-import '../interactive-o_NZb-Xg.js';
-import '../options-BcDReOJv.js';
+import '../interactive-BigrPKnu.js';
+import '@cuylabs/channel-slack/interactive';
+import '../options-CGUfVStV.js';
 import '../artifacts/index.js';
 import '@cuylabs/channel-slack/artifacts';
 import '@cuylabs/channel-slack/feedback';

package/dist/assistant/index.js

@@ -3,9 +3,9 @@ import {
   createSlackAssistantThreadContextStore,
   parseSlackMessageActivityFromMessageEvent,
   resolveAssistantSessionId
-} from "../chunk-7YZWCSML.js";
+} from "../chunk-FJP6ZFUB.js";
 import "../chunk-ELR6MQD7.js";
-import "../chunk-TMADMHBN.js";
+import "../chunk-VBGQD6JT.js";
 export {
   createSlackAssistantBridge,
   createSlackAssistantThreadContextStore,

package/dist/{chunk-TCNJY7QA.js → chunk-D4CSEAIF.js}

@@ -1,6 +1,6 @@
 import {
   createSlackChannelAdapter
-} from "./chunk-FQWFB54C.js";
+} from "./chunk-XA7U3GRN.js";
 
 // src/express.ts
 import {

package/dist/{chunk-7YZWCSML.js → chunk-FJP6ZFUB.js}

@@ -7,7 +7,7 @@ import {
   UnsupportedSlackInteractiveRequestError,
   bridgeAgentEventsToSlack,
   resolveSlackEventBridgeOptions
-} from "./chunk-TMADMHBN.js";
+} from "./chunk-VBGQD6JT.js";
 
 // src/assistant/bridge.ts
 import { Assistant } from "@slack/bolt";

package/dist/{chunk-6T6N4MRK.js → chunk-GKZRDNEB.js}

@@ -1,12 +1,12 @@
 import {
   createSlackAssistantBridge
-} from "./chunk-7YZWCSML.js";
+} from "./chunk-FJP6ZFUB.js";
 import {
   createSlackFeedbackBlock
 } from "./chunk-ELR6MQD7.js";
 import {
   createSlackChannelAdapter
-} from "./chunk-FQWFB54C.js";
+} from "./chunk-XA7U3GRN.js";
 
 // src/app-surface.ts
 var DEFAULT_TIMEOUT_MS = 12e4;

package/dist/{chunk-YSDFYHPC.js → chunk-HHXAXSG6.js}

@@ -1,9 +1,9 @@
 import {
   installSlackAgentAppSurface
-} from "./chunk-6T6N4MRK.js";
+} from "./chunk-GKZRDNEB.js";
 import {
   createSlackAssistantBridge
-} from "./chunk-7YZWCSML.js";
+} from "./chunk-FJP6ZFUB.js";
 
 // src/socket.ts
 import { createSlackSocketBoltApp } from "@cuylabs/channel-slack/transports/socket";

package/dist/{chunk-2R7B7NJR.js → chunk-JU5R6JZG.js}

@@ -1,6 +1,6 @@
 import {
   createSlackAssistantBridge
-} from "./chunk-7YZWCSML.js";
+} from "./chunk-FJP6ZFUB.js";
 
 // src/express-assistant.ts
 import {

package/dist/{chunk-236WN6JD.js → chunk-KAEZPS3U.js}

@@ -1,6 +1,6 @@
 import {
   installSlackAgentAppSurface
-} from "./chunk-6T6N4MRK.js";
+} from "./chunk-GKZRDNEB.js";
 
 // src/app.ts
 import {

package/dist/chunk-OP27SSZU.js

@@ -0,0 +1,409 @@
+// src/interactive/controller.ts
+import {
+  buildApprovalRequestMessage,
+  buildHumanInputModal,
+  buildHumanInputRequestMessage,
+  buildResolvedMessage,
+  createInMemorySlackInteractiveRequestStore,
+  decodeActionValue,
+  nowIso
+} from "@cuylabs/channel-slack/interactive";
+import { openSlackModal } from "@cuylabs/channel-slack/views";
+var DEFAULT_NAMESPACE = "agent_slack";
+var DEFAULT_REQUEST_TIMEOUT_MS = 5 * 60 * 1e3;
+var installedActionIds = /* @__PURE__ */ new WeakMap();
+function createSlackInteractiveController(options = {}) {
+  const store = options.store ?? createInMemorySlackInteractiveRequestStore();
+  const actionIds = resolveActionIds(
+    options.namespace ?? DEFAULT_NAMESPACE,
+    options.actionIds
+  );
+  const requestTimeoutMs = options.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
+  const waiters = /* @__PURE__ */ new Map();
+  const pendingIds = /* @__PURE__ */ new Set();
+  async function ensurePending(kind, request) {
+    const existing = await store.get(request.id);
+    if (existing) {
+      pendingIds.add(request.id);
+      return existing;
+    }
+    const createdAt = nowIso();
+    const record = await store.upsert({
+      id: request.id,
+      kind,
+      request,
+      status: "pending",
+      createdAt,
+      updatedAt: createdAt
+    });
+    pendingIds.add(request.id);
+    return record;
+  }
+  async function waitForResolution(kind, request, waitOptions = {}) {
+    const existing = await ensurePending(kind, request);
+    if (existing.status === "resolved" && existing.resolution) {
+      return toAgentCoreResolution(existing.resolution);
+    }
+    if (waiters.has(request.id)) {
+      throw new Error(
+        `Slack interactive request is already waiting: ${request.id}. Resolve or cancel the in-flight request before requesting again.`
+      );
+    }
+    return await new Promise((resolve, reject) => {
+      const cleanupCallbacks = [];
+      const timeoutMs = waitOptions.timeoutMs ?? requestTimeoutMs;
+      if (timeoutMs > 0) {
+        const timeoutId = setTimeout(() => {
+          void cancel(request.id, "Slack interactive request timed out.");
+        }, timeoutMs);
+        cleanupCallbacks.push(() => clearTimeout(timeoutId));
+      }
+      let abortImmediately = false;
+      if (waitOptions.signal) {
+        const onAbort = () => {
+          void cancel(request.id, "Slack interactive request aborted.");
+        };
+        if (waitOptions.signal.aborted) {
+          abortImmediately = true;
+        } else {
+          waitOptions.signal.addEventListener("abort", onAbort, {
+            once: true
+          });
+          cleanupCallbacks.push(
+            () => waitOptions.signal?.removeEventListener("abort", onAbort)
+          );
+        }
+      }
+      waiters.set(request.id, {
+        resolve,
+        reject,
+        cleanup: () => {
+          for (const cleanup of cleanupCallbacks.splice(0)) {
+            cleanup();
+          }
+        }
+      });
+      if (abortImmediately) {
+        void cancel(request.id, "Slack interactive request aborted.");
+      }
+    });
+  }
+  async function resolveRequest(requestId, resolution) {
+    const record = await store.resolve(requestId, resolution);
+    const waiter = waiters.get(requestId);
+    if (waiter) {
+      waiters.delete(requestId);
+      waiter.cleanup();
+      waiter.resolve(resolution);
+    }
+    if (record) {
+      pendingIds.delete(requestId);
+      await options.onResolve?.(requestId, resolution);
+    }
+    return record;
+  }
+  async function cancel(requestId, reason = "Cancelled") {
+    const waiter = waiters.get(requestId);
+    if (waiter) {
+      waiters.delete(requestId);
+      waiter.cleanup();
+      waiter.reject(new Error(reason));
+    }
+    const existing = await store.get(requestId);
+    if (existing?.status === "pending") {
+      await store.delete(requestId);
+      pendingIds.delete(requestId);
+      return true;
+    }
+    pendingIds.delete(requestId);
+    return Boolean(waiter);
+  }
+  async function cancelAll(reason = "Cancelled") {
+    await Promise.all(
+      [...pendingIds].map((requestId) => cancel(requestId, reason))
+    );
+  }
+  async function handleInteractiveRequest(context) {
+    const request = context.request;
+    const record = await ensurePending(context.kind, request);
+    if (record.target) {
+      return true;
+    }
+    const message = context.kind === "approval" ? buildApprovalRequestMessage(
+      request,
+      actionIds
+    ) : buildHumanInputRequestMessage(
+      request,
+      actionIds
+    );
+    const ref = await context.responder.postMessage(message);
+    await store.attachTarget(request.id, {
+      channel: ref.channel,
+      ts: ref.ts,
+      userId: context.user.userId,
+      teamId: context.user.teamId,
+      ...context.slackActivity.threadTs ? { threadTs: context.slackActivity.threadTs } : {}
+    });
+    return true;
+  }
+  function install(app) {
+    assertActionIdsCanInstall(app, actionIds);
+    app.action(actionIds.approvalAllow, async (args) => {
+      await handleAction(args, {
+        kind: "approval",
+        action: "allow"
+      });
+    });
+    app.action(actionIds.approvalDeny, async (args) => {
+      await handleAction(args, {
+        kind: "approval",
+        action: "deny"
+      });
+    });
+    app.action(actionIds.approvalRemember, async (args) => {
+      const value = firstActionValue(args);
+      const rememberScope = typeof value.rememberScope === "string" ? value.rememberScope : void 0;
+      await handleAction(args, {
+        kind: "approval",
+        action: "remember",
+        ...rememberScope ? { rememberScope } : {}
+      });
+    });
+    app.action(actionIds.humanConfirm, async (args) => {
+      await handleAction(args, {
+        kind: "human-input",
+        response: { kind: "confirm", confirmed: true, text: "Confirmed" }
+      });
+    });
+    app.action(actionIds.humanDeny, async (args) => {
+      await handleAction(args, {
+        kind: "human-input",
+        response: { kind: "confirm", confirmed: false, text: "Cancelled" }
+      });
+    });
+    app.action(actionIds.humanOpen, async (args) => {
+      await openHumanInputModal(args);
+    });
+    app.view(actionIds.humanSubmit, async (args) => {
+      await submitHumanInputModal(args);
+    });
+  }
+  async function handleAction(args, resolutionInput) {
+    const actionArgs = args;
+    await actionArgs.ack();
+    const requestId = extractRequestId(firstActionValue(args));
+    if (!requestId) return;
+    const record = await store.get(requestId);
+    if (!record || record.status === "resolved") {
+      return;
+    }
+    const actor = extractActor(actionArgs.body);
+    if (!await isAuthorized(record, actor)) {
+      await postEphemeral(
+        actionArgs,
+        "Only the original requester can resolve this request."
+      );
+      return;
+    }
+    const resolution = resolutionInput;
+    const resolved = await resolveRequest(requestId, resolution);
+    if (resolved?.target) {
+      await updateOriginalMessage(actionArgs, resolved, resolution);
+    }
+  }
+  async function openHumanInputModal(args) {
+    const actionArgs = args;
+    await actionArgs.ack();
+    const requestId = extractRequestId(firstActionValue(args));
+    if (!requestId || !actionArgs.body.trigger_id) return;
+    const record = await store.get(requestId);
+    if (!record || record.kind !== "human-input") return;
+    const actor = extractActor(actionArgs.body);
+    if (!await isAuthorized(record, actor)) {
+      await postEphemeral(
+        actionArgs,
+        "Only the original requester can answer this request."
+      );
+      return;
+    }
+    await openSlackModal({
+      client: actionArgs.client,
+      triggerId: actionArgs.body.trigger_id,
+      view: buildHumanInputModal(
+        record.request,
+        actionIds
+      )
+    });
+  }
+  async function submitHumanInputModal(args) {
+    const viewArgs = args;
+    await viewArgs.ack();
+    const requestId = extractRequestIdFromView(viewArgs.view);
+    if (!requestId) return;
+    const record = await store.get(requestId);
+    if (!record || record.kind !== "human-input" || record.status === "resolved") {
+      return;
+    }
+    const actor = extractActor(viewArgs.body);
+    if (!await isAuthorized(record, actor)) {
+      return;
+    }
+    const response = responseFromView(
+      record.request,
+      viewArgs.view
+    );
+    const resolution = {
+      kind: "human-input",
+      response
+    };
+    const resolved = await resolveRequest(requestId, resolution);
+    if (resolved?.target) {
+      await viewArgs.client.chat.update({
+        channel: resolved.target.channel,
+        ts: resolved.target.ts,
+        ...buildResolvedMessage("Slack response received.", resolution)
+      });
+    }
+  }
+  async function isAuthorized(record, actor) {
+    if (options.authorize) {
+      return await options.authorize(record, actor);
+    }
+    return record.target?.userId === actor.userId;
+  }
+  async function updateOriginalMessage(args, record, resolution) {
+    const target = record.target;
+    if (!target) return;
+    const label = resolution.kind === "approval" ? `${resolution.action} selected.` : resolution.response.text;
+    await args.client.chat.update({
+      channel: target.channel,
+      ts: target.ts,
+      ...buildResolvedMessage(label, resolution)
+    });
+  }
+  return {
+    actionIds,
+    store,
+    approval: {
+      async onRequest(request, options2) {
+        const resolution = await waitForResolution(
+          "approval",
+          request,
+          options2
+        );
+        if (resolution.kind !== "approval") {
+          throw new Error(
+            `Unexpected human-input resolution for ${request.id}.`
+          );
+        }
+        return {
+          action: resolution.action,
+          ...resolution.feedback ? { feedback: resolution.feedback } : {},
+          ...resolution.rememberScope ? { rememberScope: resolution.rememberScope } : {}
+        };
+      }
+    },
+    humanInput: {
+      async onRequest(request, options2) {
+        const resolution = await waitForResolution(
+          "human-input",
+          request,
+          options2
+        );
+        if (resolution.kind !== "human-input") {
+          throw new Error(`Unexpected approval resolution for ${request.id}.`);
+        }
+        return resolution.response;
+      }
+    },
+    cancel,
+    cancelAll,
+    handleInteractiveRequest,
+    install
+  };
+}
+function toAgentCoreResolution(resolution) {
+  return resolution;
+}
+function resolveActionIds(namespace, overrides) {
+  const prefix = normalizeActionIdNamespace(namespace);
+  return {
+    approvalAllow: `${prefix}_approval_allow`,
+    approvalDeny: `${prefix}_approval_deny`,
+    approvalRemember: `${prefix}_approval_remember`,
+    humanConfirm: `${prefix}_human_confirm`,
+    humanDeny: `${prefix}_human_deny`,
+    humanOpen: `${prefix}_human_open`,
+    humanSubmit: `${prefix}_human_submit`,
+    ...overrides ?? {}
+  };
+}
+function normalizeActionIdNamespace(namespace) {
+  const trimmed = namespace.trim();
+  if (!trimmed) {
+    throw new Error("Slack interactive action namespace cannot be empty.");
+  }
+  return trimmed;
+}
+function assertActionIdsCanInstall(app, actionIds) {
+  const ids = Object.values(actionIds);
+  const duplicateWithinController = ids.find(
+    (id, index) => ids.indexOf(id) !== index
+  );
+  if (duplicateWithinController) {
+    throw new Error(
+      `Duplicate Slack interactive action id configured: ${duplicateWithinController}`
+    );
+  }
+  const appKey = app;
+  const installed = installedActionIds.get(appKey) ?? /* @__PURE__ */ new Set();
+  const duplicate = ids.find((id) => installed.has(id));
+  if (duplicate) {
+    throw new Error(
+      `Slack interactive action id '${duplicate}' is already installed on this Bolt app. Provide a unique createSlackInteractiveController({ namespace }) or actionIds config.`
+    );
+  }
+  for (const id of ids) {
+    installed.add(id);
+  }
+  installedActionIds.set(appKey, installed);
+}
+function firstActionValue(args) {
+  const body = args.body;
+  return decodeActionValue(body.actions?.[0]?.value);
+}
+function extractRequestId(value) {
+  return typeof value.requestId === "string" && value.requestId.length > 0 ? value.requestId : void 0;
+}
+function extractRequestIdFromView(view) {
+  return extractRequestId(decodeActionValue(view.private_metadata));
+}
+function extractActor(body) {
+  return {
+    userId: body.user?.id ?? "unknown",
+    ...body.user?.team_id ?? body.team?.id ? { teamId: body.user?.team_id ?? body.team?.id } : {}
+  };
+}
+async function postEphemeral(args, text) {
+  const channel = args.body.channel?.id;
+  const user = args.body.user?.id;
+  if (!channel || !user || !args.client.chat.postEphemeral) return;
+  await args.client.chat.postEphemeral({ channel, user, text });
+}
+function responseFromView(request, view) {
+  const input = view.state?.values?.input?.value;
+  if (request.kind === "choice") {
+    const selected = input?.selected_options?.map((option) => option.value ?? "").filter(Boolean) ?? (input?.selected_option?.value ? [input.selected_option.value] : []);
+    return {
+      kind: "choice",
+      selected,
+      text: selected.join(", ")
+    };
+  }
+  const text = input?.value ?? "";
+  return { kind: "text", text };
+}
+
+export {
+  createSlackInteractiveController
+};

package/dist/{chunk-FQWFB54C.js → chunk-XA7U3GRN.js}

@@ -2,7 +2,7 @@ import {
   UnsupportedSlackInteractiveRequestError,
   bridgeAgentEventsToSlack,
   resolveSlackEventBridgeOptions
-} from "./chunk-TMADMHBN.js";
+} from "./chunk-VBGQD6JT.js";
 
 // src/adapter/adapter.ts
 import { withinScope } from "@cuylabs/agent-core";

package/dist/express-assistant.d.ts

@@ -3,13 +3,14 @@ import { Application } from 'express';
 import { App, ExpressReceiver } from '@slack/bolt';
 import { CreateSlackBoltAppOptions } from '@cuylabs/channel-slack/transports/http';
 import { SlackDirectAuthOptions, SlackDirectAuthMode } from '@cuylabs/channel-slack/auth';
-import { C as CreateSlackAssistantBridgeOptions, d as SlackAssistantFeedbackConfig, S as SlackAssistantBridge } from './options-C7-VXmhD.js';
+import { C as CreateSlackAssistantBridgeOptions, d as SlackAssistantFeedbackConfig, S as SlackAssistantBridge } from './options-ByNm2o89.js';
 import { SlackFeedbackHandler } from '@cuylabs/channel-slack/feedback';
 import '@cuylabs/agent-core';
 import '@slack/web-api';
 import '@cuylabs/channel-slack/core';
-import './interactive-o_NZb-Xg.js';
-import './options-BcDReOJv.js';
+import './interactive-BigrPKnu.js';
+import '@cuylabs/channel-slack/interactive';
+import './options-CGUfVStV.js';
 import './artifacts/index.js';
 import '@cuylabs/channel-slack/artifacts';
 import '@cuylabs/channel-slack/assistant';