@cuylabs/channel-slack 0.10.0 → 0.12.0

package/dist/interactive/index.js

@@ -1,3 +1,7 @@
+import {
+  openSlackModal
+} from "../chunk-IRFKUPJN.js";
+
 // src/interactive/blocks.ts
 var MAX_BLOCK_TEXT = 2800;
 function buildApprovalRequestMessage(request, actionIds) {
@@ -634,6 +638,433 @@ async function importPostgresPoolConstructor() {
 function formatImportError(error) {
   return error instanceof Error ? error.message : String(error);
 }
+
+// src/interactive/controller.ts
+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) {
+      assertRecordKind(existing, kind);
+      trackPending(existing);
+      return existing;
+    }
+    const createdAt = nowIso();
+    const record = await store.upsert({
+      id: request.id,
+      kind,
+      request,
+      status: "pending",
+      createdAt,
+      updatedAt: createdAt
+    });
+    assertRecordKind(record, kind);
+    trackPending(record);
+    return record;
+  }
+  function trackPending(record) {
+    if (record.status === "pending") {
+      pendingIds.add(record.id);
+    } else {
+      pendingIds.delete(record.id);
+    }
+  }
+  async function waitForResolution(kind, request, waitOptions = {}) {
+    const existing = await ensurePending(kind, request);
+    if (existing.status === "resolved") {
+      if (!existing.resolution) {
+        throw new Error(
+          `Slack interactive request ${request.id} is resolved without a resolution.`
+        );
+      }
+      return 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);
+    if (!record) {
+      const waiter2 = waiters.get(requestId);
+      if (waiter2) {
+        waiters.delete(requestId);
+        waiter2.cleanup();
+        waiter2.reject(
+          new Error(`Slack interactive request no longer exists: ${requestId}`)
+        );
+      }
+      pendingIds.delete(requestId);
+      return void 0;
+    }
+    const resolvedResolution = record.resolution ?? resolution;
+    const waiter = waiters.get(requestId);
+    if (waiter) {
+      waiters.delete(requestId);
+      waiter.cleanup();
+      waiter.resolve(resolvedResolution);
+    }
+    pendingIds.delete(requestId);
+    await options.onResolve?.(requestId, resolvedResolution);
+    return { record, resolution: resolvedResolution };
+  }
+  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.status === "resolved" || 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 resolved = await resolveRequest(requestId, resolutionInput);
+    if (resolved?.record.target) {
+      await updateOriginalMessage(
+        actionArgs,
+        resolved.record,
+        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?.record.target) {
+      await viewArgs.client.chat.update({
+        channel: resolved.record.target.channel,
+        ts: resolved.record.target.ts,
+        ...buildResolvedMessage(
+          "Slack response received.",
+          resolved.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 resolution;
+      }
+    },
+    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 assertRecordKind(record, kind) {
+  if (record.kind !== kind) {
+    throw new Error(
+      `Slack interactive request ${record.id} already exists as ${record.kind}; cannot reuse it as ${kind}.`
+    );
+  }
+}
+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 {
   buildApprovalRequestMessage,
   buildHumanInputModal,
@@ -642,6 +1073,7 @@ export {
   cloneRecord,
   createInMemorySlackInteractiveRequestStore,
   createPostgresSlackInteractiveRequestStore,
+  createSlackInteractiveController,
   decodeActionValue,
   encodeActionValue,
   initializePostgresSlackInteractiveRequestStore,

package/dist/options-B0xQCaez.d.ts

@@ -0,0 +1,221 @@
+import { d as SlackArtifactClient, g as SlackArtifactPublication } from './types-C8nkPuD4.js';
+import { c as SlackInteractiveApprovalRequest, e as SlackInteractiveHumanInputRequest } from './types-Cywfj8Mj.js';
+import { a as SlackEventInteractiveRequestHandler } from './interactive-CbKYkkc_.js';
+
+interface SlackTurnSourceChatOptions {
+    abort?: AbortSignal;
+    system?: string;
+}
+interface SlackTurnSource {
+    chat(sessionId: string, message: string, options?: SlackTurnSourceChatOptions): AsyncGenerator<SlackTurnEvent>;
+}
+interface SlackFinalResponseArtifactContext {
+    text: string;
+    formattedText: string;
+    client: SlackArtifactClient;
+    channelId: string;
+    threadTs?: string;
+}
+interface SlackFinalResponseArtifactResult {
+    publication: SlackArtifactPublication;
+}
+type SlackFinalResponseArtifactDeliveryMode = "supplemental" | "replace";
+type SlackFinalResponseArtifactPublisher = (context: SlackFinalResponseArtifactContext) => Promise<SlackFinalResponseArtifactResult | undefined>;
+type SlackTurnStatus = "thinking" | "reasoning" | "calling-tool" | "waiting-approval" | "waiting-input" | "processing" | "error" | string;
+interface SlackTurnEventBase {
+    type: string;
+    [key: string]: unknown;
+}
+interface SlackTurnTextStartEvent extends SlackTurnEventBase {
+    type: "text-start";
+}
+interface SlackTurnTextDeltaEvent extends SlackTurnEventBase {
+    type: "text-delta";
+    text: string;
+}
+interface SlackTurnTextEndEvent extends SlackTurnEventBase {
+    type: "text-end";
+}
+interface SlackTurnReasoningStartEvent extends SlackTurnEventBase {
+    type: "reasoning-start";
+}
+interface SlackTurnReasoningEndEvent extends SlackTurnEventBase {
+    type: "reasoning-end";
+}
+interface SlackTurnToolStartEvent extends SlackTurnEventBase {
+    type: "tool-start";
+    toolCallId: string;
+    toolName: string;
+    input?: unknown;
+}
+interface SlackTurnToolResultEvent extends SlackTurnEventBase {
+    type: "tool-result";
+    toolCallId: string;
+    toolName: string;
+    result?: unknown;
+}
+interface SlackTurnToolErrorEvent extends SlackTurnEventBase {
+    type: "tool-error";
+    toolCallId: string;
+    toolName: string;
+    error: string;
+}
+interface SlackTurnSubagentEventBase extends SlackTurnEventBase {
+    dispatchId: string;
+    role: string;
+    title?: string;
+    parentDispatchId?: string;
+    agentPath?: string;
+    depth?: number;
+}
+interface SlackTurnSubagentStartEvent extends SlackTurnSubagentEventBase {
+    type: "subagent-start";
+}
+interface SlackTurnSubagentEventEvent extends SlackTurnSubagentEventBase {
+    type: "subagent-event";
+    event: SlackTurnEvent;
+}
+interface SlackTurnSubagentCompleteEvent extends SlackTurnSubagentEventBase {
+    type: "subagent-complete";
+    output?: unknown;
+}
+interface SlackTurnSubagentErrorEvent extends SlackTurnSubagentEventBase {
+    type: "subagent-error";
+    error: string;
+}
+interface SlackTurnStatusEvent extends SlackTurnEventBase {
+    type: "status";
+    status: SlackTurnStatus;
+}
+interface SlackTurnCompleteEvent extends SlackTurnEventBase {
+    type: "complete";
+    output?: string;
+}
+interface SlackTurnErrorEvent extends SlackTurnEventBase {
+    type: "error";
+    error: unknown;
+}
+interface SlackTurnApprovalRequestEvent extends SlackTurnEventBase {
+    type: "approval-request";
+    request: SlackInteractiveApprovalRequest;
+}
+interface SlackTurnApprovalResolvedEvent extends SlackTurnEventBase {
+    type: "approval-resolved";
+}
+interface SlackTurnHumanInputRequestEvent extends SlackTurnEventBase {
+    type: "human-input-request";
+    request: SlackInteractiveHumanInputRequest;
+}
+interface SlackTurnHumanInputResolvedEvent extends SlackTurnEventBase {
+    type: "human-input-resolved";
+}
+type SlackTurnEvent = SlackTurnTextStartEvent | SlackTurnTextDeltaEvent | SlackTurnTextEndEvent | SlackTurnReasoningStartEvent | SlackTurnReasoningEndEvent | SlackTurnToolStartEvent | SlackTurnToolResultEvent | SlackTurnToolErrorEvent | SlackTurnSubagentStartEvent | SlackTurnSubagentEventEvent | SlackTurnSubagentCompleteEvent | SlackTurnSubagentErrorEvent | SlackTurnStatusEvent | SlackTurnCompleteEvent | SlackTurnErrorEvent | SlackTurnApprovalRequestEvent | SlackTurnApprovalResolvedEvent | SlackTurnHumanInputRequestEvent | SlackTurnHumanInputResolvedEvent;
+
+/**
+ * Event-bridge configuration. The bridge is mode-aware (progressive,
+ * accumulate, chat-stream) and these options control formatting, status
+ * propagation, interactive-request handling, and chat-stream finalization.
+ */
+
+type ApprovalRequest = SlackTurnApprovalRequestEvent["request"];
+type HumanInputRequest = SlackTurnHumanInputRequestEvent["request"];
+interface SlackEventBridgeOptions {
+    showReasoning: boolean;
+    /** Render root-agent tool rows/status updates. */
+    showToolUsage: boolean;
+    /** Render subagent child tool rows in the parent Slack task timeline. */
+    showSubagentToolUsage: boolean;
+    /** Include full subagent completion output in the subagent task row. */
+    showSubagentResultInTask: boolean;
+    formatToolTitle?: (toolName: string) => string;
+    formatToolUpdate: (toolName: string) => string;
+    formatToolDetails?: (event: SlackTurnToolStartEvent) => string | undefined;
+    /**
+     * Format the completed tool output shown in Slack task rows.
+     *
+     * Return `undefined` to use the default generic formatter. Return `null` to
+     * intentionally omit task-row output for this tool result.
+     */
+    formatToolResultOutput?: (event: SlackTurnToolResultEvent) => string | null | undefined;
+    formatToolError: (toolName: string, error: string) => string;
+    formatReasoningUpdate: () => string;
+    formatMessageText: (text: string) => string;
+    streamingMode: "progressive" | "accumulate" | "chat-stream";
+    progressiveUpdateThreshold: number;
+    progressiveUpdateIntervalMs: number;
+    chatStreamBufferSize: number;
+    /**
+     * Maximum number of Slack task-update chunks the bridge will append to a
+     * single chat stream. Task rows are a bounded UI projection, not a durable
+     * event log.
+     */
+    maxTaskUpdates: number;
+    /**
+     * Maximum cumulative characters from task titles/details/output that the
+     * bridge will append to one chat stream.
+     */
+    maxTaskUpdateTextChars: number;
+    /**
+     * Maximum characters for a single task details/output field.
+     */
+    maxTaskUpdateFieldChars: number;
+    interactiveMode: "message-and-error" | "ignore";
+    handleInteractiveRequest?: SlackEventInteractiveRequestHandler;
+    formatApprovalRequired: (request: ApprovalRequest) => string;
+    formatHumanInputRequired: (request: HumanInputRequest) => string;
+    /**
+     * Optional hook called whenever the bridge's status label changes — used by
+     * the assistant bridge to update the assistant pane's status line via
+     * `assistant.threads.setStatus`. Errors are swallowed by the caller.
+     */
+    onStatusChange?: (label: string, event: SlackTurnEvent | undefined) => void | Promise<void>;
+    /**
+     * Optional final-args passthrough for `chatStream.stop(...)`. When the
+     * bridge stops the chat stream on `complete`, these args (e.g. final
+     * `blocks` for a feedback widget) are merged into the `stop` call. The
+     * existing `markdown_text` final-text fallback always wins on text fields.
+     */
+    chatStreamFinalArgs?: {
+        blocks?: unknown[];
+    } & Record<string, unknown>;
+    /**
+     * Optional post-processing hook for publishing a rich artifact from the final
+     * accumulated response, such as a Slack Canvas for long answers.
+     */
+    publishFinalResponseArtifact?: SlackFinalResponseArtifactPublisher;
+    /**
+     * Controls whether artifact publication is additive or becomes the primary
+     * final-answer surface.
+     *
+     * - `supplemental`: finalize the Slack text normally, then publish artifact.
+     * - `replace`: publish artifact first and use a compact Slack final message.
+     *
+     * @default "supplemental"
+     */
+    finalResponseArtifactMode?: SlackFinalResponseArtifactDeliveryMode;
+    /**
+     * When replacement mode is active, continue streaming text up to this many
+     * raw characters, then suppress further text deltas and publish the full
+     * answer as an artifact at completion. This preserves normal short-answer
+     * streaming without flooding Slack for long answers.
+     *
+     * @default 4000
+     */
+    finalResponseArtifactStreamThreshold?: number;
+    /**
+     * Notice appended when replacement mode suppresses the remaining text stream.
+     */
+    formatFinalResponseArtifactContinuationNotice?: (context: Pick<SlackFinalResponseArtifactContext, "text" | "formattedText">) => string;
+    /**
+     * Final compact message used when an artifact replaces the full Slack text.
+     */
+    formatFinalResponseArtifactMessage?: (result: SlackFinalResponseArtifactResult, context: SlackFinalResponseArtifactContext) => string;
+    /**
+     * Called when `publishFinalResponseArtifact` throws. Errors from this hook
+     * are swallowed so artifact publication cannot break a completed turn.
+     */
+    onFinalResponseArtifactError?: (error: unknown, context: SlackFinalResponseArtifactContext) => void | Promise<void>;
+}
+declare function resolveSlackEventBridgeOptions(partial: Partial<SlackEventBridgeOptions>): SlackEventBridgeOptions;
+
+export { type SlackTurnToolErrorEvent as A, type SlackTurnToolResultEvent as B, type SlackTurnToolStartEvent as C, resolveSlackEventBridgeOptions as D, type SlackEventBridgeOptions as S, type SlackFinalResponseArtifactContext as a, type SlackFinalResponseArtifactDeliveryMode as b, type SlackFinalResponseArtifactPublisher as c, type SlackFinalResponseArtifactResult as d, type SlackTurnApprovalRequestEvent as e, type SlackTurnApprovalResolvedEvent as f, type SlackTurnCompleteEvent as g, type SlackTurnErrorEvent as h, type SlackTurnEvent as i, type SlackTurnEventBase as j, type SlackTurnHumanInputRequestEvent as k, type SlackTurnHumanInputResolvedEvent as l, type SlackTurnReasoningEndEvent as m, type SlackTurnReasoningStartEvent as n, type SlackTurnSource as o, type SlackTurnSourceChatOptions as p, type SlackTurnStatus as q, type SlackTurnStatusEvent as r, type SlackTurnSubagentCompleteEvent as s, type SlackTurnSubagentErrorEvent as t, type SlackTurnSubagentEventBase as u, type SlackTurnSubagentEventEvent as v, type SlackTurnSubagentStartEvent as w, type SlackTurnTextDeltaEvent as x, type SlackTurnTextEndEvent as y, type SlackTurnTextStartEvent as z };