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

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-236WN6JD.js → chunk-P2DIC42J.js}

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

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

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

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

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

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

package/dist/express-assistant.js

@@ -1,9 +1,9 @@
 import {
   mountSlackAssistantAgent
-} from "./chunk-2R7B7NJR.js";
-import "./chunk-7YZWCSML.js";
+} from "./chunk-DS6E5OEJ.js";
+import "./chunk-GEFK72VO.js";
 import "./chunk-ELR6MQD7.js";
-import "./chunk-TMADMHBN.js";
+import "./chunk-L5RAGYVJ.js";
 export {
   mountSlackAssistantAgent
 };

package/dist/express.d.ts

@@ -2,15 +2,16 @@ import * as _slack_bolt from '@slack/bolt';
 import { Server } from 'node:http';
 import { AgentTurnSource } from '@cuylabs/agent-core';
 import { Application } from 'express';
-import { c as createSlackChannelAdapter } from './adapter-B3CI611y.js';
-import { a as SlackChannelOptions } from './types-CRWzJB5G.js';
+import { c as createSlackChannelAdapter } from './adapter-vbqtraAr.js';
+import { a as SlackChannelOptions } from './types-BeGPexio.js';
 import { CreateSlackBoltAppOptions } from '@cuylabs/channel-slack/transports/http';
 import { SlackDirectAuthOptions, SlackDirectAuthMode } from '@cuylabs/channel-slack/auth';
 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';
 
 interface MountSlackAgentOptions extends Omit<SlackChannelOptions, "agent" | "source">, Omit<CreateSlackBoltAppOptions, "app" | "path" | "botToken" | "signingSecret" | "auth"> {
     /**

package/dist/express.js

@@ -1,8 +1,8 @@
 import {
   mountSlackAgent
-} from "./chunk-TCNJY7QA.js";
-import "./chunk-FQWFB54C.js";
-import "./chunk-TMADMHBN.js";
+} from "./chunk-QFDXKCAQ.js";
+import "./chunk-KQPUQJ57.js";
+import "./chunk-L5RAGYVJ.js";
 export {
   mountSlackAgent
 };

package/dist/history/index.d.ts

@@ -4,16 +4,17 @@ import { MountSlackAgentAppTurnRequestContext } from '../app-surface.js';
 import { a as SlackContextFragmentPayload } from '../context-fragments-CQEDcjYR.js';
 import '@slack/bolt';
 import '@slack/web-api';
-import '../options-C7-VXmhD.js';
+import '../options-ByNm2o89.js';
 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';
 import '@cuylabs/channel-slack/assistant';
-import '../types-CRWzJB5G.js';
-import '../types-Crpil4kb.js';
+import '../types-BeGPexio.js';
+import '../types-Bz4OYEAV.js';
 import '../types-CiwGU6zC.js';
 import '@cuylabs/channel-slack/views';
 

package/dist/index.d.ts

@@ -1,17 +1,17 @@
 export { D as DEFAULT_SLACK_CONTEXT_FRAGMENT_KEY, S as SlackContextFragmentMiddlewareOptions, a as SlackContextFragmentPayload, b as SlackContextFragmentResolver, c as SlackContextFragmentResolverContext, d as createSlackContextFragmentMiddleware } from './context-fragments-CQEDcjYR.js';
-export { SlackArtifactPublicationTarget, SlackChatStream, SlackResponseSink, SlackStreamChunk, SlackStreamTaskStatus, UnsupportedSlackInteractiveRequestError, bridgeAgentEventsToSlack } from './shared/index.js';
-export { S as SlackEventBridgeOptions, r as resolveSlackEventBridgeOptions } from './options-BcDReOJv.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-o_NZb-Xg.js';
-export { c as createSlackChannelAdapter } from './adapter-B3CI611y.js';
-export { S as SlackChannelAdapter, a as SlackChannelOptions, b as SlackSessionStrategy, c as SlackStreamingMode, d as SlackToolStartEvent } from './types-CRWzJB5G.js';
+export { UnsupportedSlackInteractiveRequestError, bridgeAgentEventsToSlack, mapAgentEventToSlackTurnEvent, mapAgentSlackEventBridgeOptionsToRuntimeOptions } from './shared/index.js';
+export { S as SlackEventBridgeOptions, r as resolveSlackEventBridgeOptions } from './options-CGUfVStV.js';
+export { S as SlackApprovalRequest, a as SlackEventInteractiveRequestHandler, b as SlackHumanInputRequest, c as SlackInteractiveRequest, d as SlackInteractiveRequestBaseContext, e as SlackInteractiveRequestContext, f as SlackInteractiveRequestHandler } from './interactive-BigrPKnu.js';
+export { c as createSlackChannelAdapter } from './adapter-vbqtraAr.js';
+export { S as SlackChannelAdapter, a as SlackChannelOptions, b as SlackSessionStrategy, c as SlackStreamingMode, d as SlackToolStartEvent } from './types-BeGPexio.js';
 export { SlackSessionMap, createSlackSessionMap } from './adapter/index.js';
 export { createSlackAssistantBridge } from './assistant/index.js';
-export { A as AssistantLifecycleArgs, a as AssistantThreadStartedArgs, C as CreateSlackAssistantBridgeOptions, M as MaybePromise, S as SlackAssistantBridge, 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';
+export { A as AssistantLifecycleArgs, a as AssistantThreadStartedArgs, C as CreateSlackAssistantBridgeOptions, M as MaybePromise, S as SlackAssistantBridge, 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';
 export { CreateSlackFinalResponseArtifactPublisherOptions, SlackFinalResponseArtifactContext, SlackFinalResponseArtifactDeliveryMode, SlackFinalResponseArtifactPublisher, SlackFinalResponseArtifactResult, SlackFinalResponseArtifactValueResolver, createSlackFinalResponseArtifactPublisher } from './artifacts/index.js';
 export { LoadSlackAgentTurnHistoryContextOptions, SlackAgentTurnHistoryContextResult, SlackAgentTurnHistoryOptions, SlackAgentTurnHistoryProfileResolver, emptySlackAgentTurnHistoryContextResult, loadSlackAgentTurnHistoryContext } from './history/index.js';
-export { S as SlackInteractiveActionIds, a as SlackInteractiveActor, b as SlackInteractiveApprovalRequest, c as SlackInteractiveController, d as SlackInteractiveControllerOptions, e as SlackInteractiveHumanInputRequest, f as SlackInteractiveMessageTarget, g as SlackInteractivePendingWaiter, h as SlackInteractivePostedMessage, i as SlackInteractiveRequestRecord, j as SlackInteractiveRequestStatus, k as SlackInteractiveRequestStore, l as SlackInteractiveRequestWaitOptions, m as SlackInteractiveResolution, n as SlackInteractiveStoredRequest } from './types-Crpil4kb.js';
-export { PostgresSlackInteractiveRequestPruneResult, PostgresSlackInteractiveRequestStore, PostgresSlackInteractiveRequestStoreOptions, SlackInteractivePostgresClient, buildApprovalRequestMessage, buildHumanInputModal, buildHumanInputRequestMessage, buildResolvedMessage, cloneRecord, createInMemorySlackInteractiveRequestStore, createPostgresSlackInteractiveRequestStore, createSlackInteractiveController, decodeActionValue, encodeActionValue, initializePostgresSlackInteractiveRequestStore, nowIso, prunePostgresSlackInteractiveRequestStore } from './interactive/index.js';
+export { S as SlackInteractiveApprovalRequest, a as SlackInteractiveController, b as SlackInteractiveControllerOptions, c as SlackInteractiveHumanInputRequest, d as SlackInteractivePendingWaiter, e as SlackInteractivePostedMessage, f as SlackInteractiveRequestWaitOptions, g as SlackInteractiveResolution } from './types-Bz4OYEAV.js';
+export { createSlackInteractiveController } from './interactive/index.js';
 export { createSlackAgentViewWorkflowController } from './views/index.js';
 export { C as CreateSlackAgentViewWorkflowControllerOptions, S as SlackAgentViewStateValue, a as SlackAgentViewStateValues, b as SlackAgentViewWorkflow, c as SlackAgentViewWorkflowContext, d as SlackAgentViewWorkflowController, e as SlackAgentViewWorkflowDefinition, f as extractSlackAgentViewStateValues, r as readSlackAgentViewStateValue } from './types-CiwGU6zC.js';
 export { InspectSlackTurnStatusVisibilityOptions, ResolvedSlackTurnStatusVisibilityOptions, RouteSlackAgentEventOptions, SlackActiveToolCall, SlackAgentEventQueue, SlackAgentEventQueueState, SlackSubagentCompletionMessage, SlackSubagentCompletionMessageFormatterOptions, SlackSubagentCompletionNotifierOptions, SlackSubagentCompletionPoster, SlackSubagentCompletionRun, SlackSubagentCompletionSlackContext, SlackSubagentCompletionTurnContext, SlackTurnActivityState, SlackTurnPhase, SlackTurnStatusVisibilityOptions, SlackTurnStatusVisibilityState, SlackTurnStatusVisibilityWarning, SlackTypedApprovalAction, coalesceSlackAgentEvents, createSlackSubagentCompletionNotifier, formatDefaultSlackSubagentCompletionMessage, immediateSlackTextResponse, inspectSlackTurnStatusVisibility, isAbortLikeError, isRunningAgentTurnError, isSlackCancelMessage, isSlackSubagentTerminalEvent, isSlackTerminalTurnPhase, isSlackWaitingForHumanTurnPhase, recordSlackTurnActivity, resolveSlackTurnStatusVisibilityOptions, resolveSlackTypedApprovalAction, routeSlackAgentEvent, shouldInspectSlackTurnStatusVisibility, shouldQueueSlackAgentEvent } from './source/index.js';
@@ -23,12 +23,14 @@ export { CreateSlackMcpServerConfigOptions, SLACK_MCP_URL, createSlackMcpServerC
 export { MountSlackAgentAppTurnRequestContext } from './app-surface.js';
 import '@cuylabs/agent-core';
 import '@cuylabs/channel-slack/core';
-import '@cuylabs/channel-slack/artifacts';
+import '@cuylabs/channel-slack/responses';
+import '@cuylabs/channel-slack/runtime';
+import '@cuylabs/channel-slack/interactive';
 import '@slack/bolt';
 import '@slack/web-api';
 import '@cuylabs/channel-slack/feedback';
+import '@cuylabs/channel-slack/artifacts';
 import '@cuylabs/channel-slack/history';
-import '@slack/types';
 import '@cuylabs/channel-slack/views';
 import '@cuylabs/agent-core/dispatch';
 import 'node:http';