@cuylabs/channel-slack-agent-core 0.5.1 → 0.6.0

package/dist/chunk-C7VSW4ZM.js

@@ -0,0 +1,548 @@
+// src/source/event-queue.ts
+function coalesceSlackAgentEvents(previous, next) {
+  if (previous.type === "text-delta" && next.type === "text-delta") {
+    return {
+      type: "text-delta",
+      text: previous.text + next.text
+    };
+  }
+  return void 0;
+}
+function routeSlackAgentEvent({
+  event,
+  logger,
+  onRecord,
+  queue,
+  sequence,
+  state
+}) {
+  if (sequence !== void 0) {
+    if (state.deliveredSequences.has(sequence)) {
+      logger?.debug?.("Skipping duplicate Slack agent event", {
+        eventType: event.type,
+        sequence,
+        sessionId: state.sessionId,
+        turnId: state.turnId
+      });
+      return false;
+    }
+    state.deliveredSequences.add(sequence);
+  }
+  onRecord?.(event, sequence);
+  if (!shouldQueueSlackAgentEvent({ event, logger, sequence, state })) {
+    return false;
+  }
+  queue.push(event, coalesceSlackAgentEvents);
+  return true;
+}
+function shouldQueueSlackAgentEvent({
+  event,
+  logger,
+  sequence,
+  state
+}) {
+  const status = slackAgentEventStatusKey(event);
+  if (!status) {
+    if (event.type === "subagent-complete" || event.type === "subagent-error") {
+      state.lastQueuedStatusByKey.delete(`subagent:${event.dispatchId}`);
+    }
+    return true;
+  }
+  const previous = state.lastQueuedStatusByKey.get(status.key);
+  if (previous === status.status) {
+    logger?.debug?.("Skipping duplicate Slack status event", {
+      eventType: event.type,
+      sequence,
+      sessionId: state.sessionId,
+      status: status.status,
+      statusKey: status.key,
+      turnId: state.turnId
+    });
+    return false;
+  }
+  state.lastQueuedStatusByKey.set(status.key, status.status);
+  return true;
+}
+function slackAgentEventStatusKey(event) {
+  if (event.type === "status") {
+    return { key: "root", status: event.status };
+  }
+  if (event.type === "subagent-event" && event.event.type === "status") {
+    return {
+      key: `subagent:${event.dispatchId}`,
+      status: event.event.status
+    };
+  }
+  return void 0;
+}
+
+// src/source/responses.ts
+async function* immediateSlackTextResponse(text) {
+  yield { type: "text-start" };
+  yield { type: "text-delta", text };
+  yield { type: "text-end" };
+  yield { type: "complete", output: text };
+}
+function isSlackCancelMessage(message) {
+  const normalized = message.trim().toLowerCase();
+  return /^(cancel|stop|abort|nevermind|never mind|discard|quit)\b[.!?]*$/.test(
+    normalized
+  );
+}
+function resolveSlackTypedApprovalAction(message) {
+  const normalized = message.trim().toLowerCase();
+  if (/^(allow|approve|approved|yes|y)\b[.!?]*$/.test(normalized)) {
+    return "allow";
+  }
+  if (/^(deny|denied|no|n)\b[.!?]*$/.test(normalized)) {
+    return "deny";
+  }
+  if (/^(remember|always|allow always|approve always)\b[.!?]*$/.test(normalized)) {
+    return "remember";
+  }
+  return void 0;
+}
+function isRunningAgentTurnError(error) {
+  return error instanceof Error && /already has a running turn/i.test(error.message);
+}
+function isAbortLikeError(error) {
+  if (error instanceof DOMException) {
+    return error.name === "AbortError";
+  }
+  if (error instanceof Error) {
+    return error.name === "AbortError" || /aborted/i.test(error.message);
+  }
+  return false;
+}
+
+// src/source/status-visibility.ts
+function resolveSlackTurnStatusVisibilityOptions(options) {
+  return {
+    checkIntervalMs: Math.max(1, normalizeMs(options?.checkIntervalMs, 5e3)),
+    toolStaleWarningMs: normalizeMs(options?.toolStaleWarningMs, 0),
+    turnStaleWarningMs: normalizeMs(options?.turnStaleWarningMs, 0)
+  };
+}
+function shouldInspectSlackTurnStatusVisibility(options) {
+  return options.toolStaleWarningMs > 0 || options.turnStaleWarningMs > 0;
+}
+function recordSlackTurnActivity(state, event, nowMs = Date.now()) {
+  state.lastActivityAtMs = nowMs;
+  switch (event.type) {
+    case "text-start":
+    case "text-delta":
+    case "text-end":
+      state.phase = "streaming";
+      state.currentTool = void 0;
+      break;
+    case "reasoning-start":
+    case "reasoning-delta":
+    case "reasoning-end":
+    case "message":
+    case "step-start":
+    case "step-finish":
+    case "status":
+    case "turn-boundary":
+      if (!isSlackTerminalTurnPhase(state.phase)) {
+        state.phase = "reasoning";
+      }
+      break;
+    case "tool-start":
+      state.phase = "tool-running";
+      state.currentTool = {
+        startedAtMs: nowMs,
+        toolCallId: event.toolCallId,
+        toolName: event.toolName
+      };
+      break;
+    case "tool-result":
+    case "tool-error":
+      if (state.currentTool?.toolCallId === event.toolCallId) {
+        state.currentTool = void 0;
+      }
+      if (!isSlackTerminalTurnPhase(state.phase)) {
+        state.phase = "reasoning";
+      }
+      break;
+    case "approval-request":
+      state.currentTool = void 0;
+      state.phase = "waiting-approval";
+      break;
+    case "approval-resolved":
+      if (!isSlackTerminalTurnPhase(state.phase)) {
+        state.phase = "reasoning";
+      }
+      break;
+    case "human-input-request":
+      state.currentTool = void 0;
+      state.phase = "waiting-input";
+      break;
+    case "human-input-resolved":
+      if (!isSlackTerminalTurnPhase(state.phase)) {
+        state.phase = "reasoning";
+      }
+      break;
+    case "complete":
+      state.currentTool = void 0;
+      state.phase = "completed";
+      break;
+    case "error":
+      state.currentTool = void 0;
+      state.phase = "failed";
+      break;
+    default:
+      break;
+  }
+}
+function inspectSlackTurnStatusVisibility({
+  formatToolStaleStatus = defaultToolStaleStatus,
+  formatTurnStaleStatus = defaultTurnStaleStatus,
+  nowMs = Date.now(),
+  options,
+  state
+}) {
+  if (isSlackTerminalTurnPhase(state.phase) || isSlackWaitingForHumanTurnPhase(state.phase)) {
+    return void 0;
+  }
+  if (state.currentTool && options.toolStaleWarningMs > 0) {
+    const elapsedMs = nowMs - state.currentTool.startedAtMs;
+    if (elapsedMs >= options.toolStaleWarningMs) {
+      return createSlackTurnStatusVisibilityWarning({
+        id: `tool:${state.currentTool.toolCallId}`,
+        message: formatToolStaleStatus(state.currentTool.toolName),
+        nowMs,
+        state,
+        thresholdMs: options.toolStaleWarningMs,
+        type: "tool"
+      });
+    }
+  }
+  if (options.turnStaleWarningMs <= 0) {
+    return void 0;
+  }
+  const idleMs = nowMs - state.lastActivityAtMs;
+  if (idleMs < options.turnStaleWarningMs) {
+    return void 0;
+  }
+  return createSlackTurnStatusVisibilityWarning({
+    id: `turn:${state.phase}`,
+    message: formatTurnStaleStatus(state.phase),
+    nowMs,
+    state,
+    thresholdMs: options.turnStaleWarningMs,
+    type: "turn"
+  });
+}
+function isSlackWaitingForHumanTurnPhase(phase) {
+  return phase === "waiting-approval" || phase === "waiting-input";
+}
+function isSlackTerminalTurnPhase(phase) {
+  return phase === "completed" || phase === "failed" || phase === "cancelled";
+}
+function createSlackTurnStatusVisibilityWarning({
+  id,
+  message,
+  nowMs,
+  state,
+  thresholdMs,
+  type
+}) {
+  if (state.statusWarningsSent.has(id)) {
+    return void 0;
+  }
+  state.statusWarningsSent.add(id);
+  const receivedEventCount = Object.values(state.eventCounts).reduce(
+    (total, count) => total + count,
+    0
+  );
+  const idleMs = type === "tool" && state.currentTool ? nowMs - state.currentTool.startedAtMs : nowMs - state.lastActivityAtMs;
+  return {
+    elapsedMs: nowMs - state.startedAtMs,
+    ...state.firstEventAtMs === void 0 ? {} : { firstEventLatencyMs: state.firstEventAtMs - state.startedAtMs },
+    ...state.firstEventType ? { firstEventType: state.firstEventType } : {},
+    id,
+    idleMs,
+    message,
+    phase: state.phase,
+    receivedEventCount,
+    ...state.sessionId ? { sessionId: state.sessionId } : {},
+    staleBeforeFirstEvent: receivedEventCount === 0,
+    thresholdMs,
+    ...state.currentTool ? {
+      toolCallId: state.currentTool.toolCallId,
+      toolName: state.currentTool.toolName
+    } : {},
+    ...state.turnId ? { turnId: state.turnId } : {},
+    type
+  };
+}
+function defaultToolStaleStatus(toolName) {
+  return `Still waiting on ${toolName}...`;
+}
+function defaultTurnStaleStatus(phase) {
+  switch (phase) {
+    case "streaming":
+      return "The response stream is taking longer than expected. I am still working on it.";
+    case "tool-running":
+      return "A tool is taking longer than expected. I am still waiting for it.";
+    default:
+      return "This request is taking longer than expected. I am still working on it.";
+  }
+}
+function normalizeMs(value, fallback) {
+  if (value === void 0 || !Number.isFinite(value) || value < 0) {
+    return fallback;
+  }
+  return Math.floor(value);
+}
+
+// src/source/subagent-completion-notifier.ts
+function createSlackSubagentCompletionNotifier({
+  enabled = true,
+  formatMessage = formatDefaultSlackSubagentCompletionMessage,
+  logger,
+  postMessage: initialPostMessage
+} = {}) {
+  const runningByDispatchId = /* @__PURE__ */ new Map();
+  const detachedTurnIds = /* @__PURE__ */ new Set();
+  const deliveredInlineDispatchIds = /* @__PURE__ */ new Set();
+  const postedTerminalKeys = /* @__PURE__ */ new Set();
+  let postMessage = initialPostMessage;
+  function trackStartedRun(turn, event) {
+    if (!enabled || deliveredInlineDispatchIds.has(event.dispatchId)) {
+      return;
+    }
+    const slack = slackThreadContext(turn.slack);
+    if (!slack) {
+      logger?.debug?.("Skipping subagent Slack notification tracking", {
+        dispatchId: event.dispatchId,
+        reason: "missing-slack-thread-context",
+        sessionId: turn.sessionId,
+        turnId: turn.turnId
+      });
+      return;
+    }
+    runningByDispatchId.set(event.dispatchId, {
+      dispatchId: event.dispatchId,
+      role: event.role,
+      sessionId: turn.sessionId,
+      slack,
+      title: event.title,
+      turnId: turn.turnId
+    });
+  }
+  function markResultDeliveredInline(event) {
+    deliveredInlineDispatchIds.add(event.dispatchId);
+    runningByDispatchId.delete(event.dispatchId);
+  }
+  function markTurnDetached(turnId) {
+    detachedTurnIds.add(turnId);
+  }
+  async function postDetachedCompletionsFromEventStore(eventStore) {
+    if (!enabled || runningByDispatchId.size === 0) {
+      return;
+    }
+    let records;
+    try {
+      records = await eventStore.list({
+        type: ["subagent-complete", "subagent-error"]
+      });
+    } catch (error) {
+      logger?.warn?.(
+        "Failed to inspect dispatch events for Slack notifications",
+        {
+          error: formatNotifierError(error)
+        }
+      );
+      return;
+    }
+    for (const record of records) {
+      if (!isSlackSubagentTerminalEvent(record.event)) {
+        continue;
+      }
+      const run = runningByDispatchId.get(record.dispatchId);
+      if (!run || !detachedTurnIds.has(run.turnId)) {
+        continue;
+      }
+      await postTerminalEvent(record.event);
+    }
+  }
+  async function postTerminalEvent(event) {
+    if (!enabled || deliveredInlineDispatchIds.has(event.dispatchId)) {
+      return;
+    }
+    const key = `${event.dispatchId}:${event.type}`;
+    if (postedTerminalKeys.has(key)) {
+      return;
+    }
+    const run = runningByDispatchId.get(event.dispatchId);
+    if (!run) {
+      logger?.debug?.("Skipping detached subagent Slack notification", {
+        dispatchId: event.dispatchId,
+        eventType: event.type,
+        reason: "missing-tracked-start"
+      });
+      return;
+    }
+    if (!postMessage) {
+      logger?.debug?.("Skipping detached subagent Slack notification", {
+        dispatchId: event.dispatchId,
+        eventType: event.type,
+        reason: "missing-slack-poster"
+      });
+      return;
+    }
+    try {
+      await postMessage(formatMessage({ event, run }));
+      postedTerminalKeys.add(key);
+      runningByDispatchId.delete(event.dispatchId);
+      logger?.info?.("Slack subagent completion notification sent", {
+        channelId: run.slack.channelId,
+        dispatchId: event.dispatchId,
+        eventType: event.type,
+        sessionId: run.sessionId,
+        threadTs: run.slack.threadTs,
+        turnId: run.turnId
+      });
+    } catch (error) {
+      logger?.warn?.("Failed to send Slack subagent completion notification", {
+        dispatchId: event.dispatchId,
+        error: formatNotifierError(error),
+        eventType: event.type,
+        sessionId: run.sessionId,
+        turnId: run.turnId
+      });
+    }
+  }
+  return {
+    clear() {
+      runningByDispatchId.clear();
+      detachedTurnIds.clear();
+      deliveredInlineDispatchIds.clear();
+      postedTerminalKeys.clear();
+    },
+    markResultDeliveredInline,
+    markTurnDetached,
+    postDetachedCompletionsFromEventStore,
+    postTerminalEvent,
+    setPostMessage(nextPostMessage) {
+      postMessage = nextPostMessage;
+    },
+    trackStartedRun
+  };
+}
+function isSlackSubagentTerminalEvent(event) {
+  return event.type === "subagent-complete" || event.type === "subagent-error";
+}
+function formatDefaultSlackSubagentCompletionMessage({
+  event,
+  run
+}) {
+  const roleTitle = formatRoleTitle(event.role || run.role);
+  const title = event.title || run.title || roleTitle;
+  const dispatchId = event.dispatchId || run.dispatchId;
+  const completed = event.type === "subagent-complete";
+  const statusText = completed ? "Result ready" : event.status === "cancelled" ? "Cancelled" : "Failed";
+  const heading = completed ? "Subagent result ready" : "Subagent stopped";
+  const instruction = completed ? `Ask me to retrieve the result for subagent \`${escapeCode(dispatchId)}\`.` : `The subagent did not finish successfully: ${event.error}`;
+  const fallback = [
+    `${roleTitle} ${statusText.toLowerCase()}: ${title}`,
+    "",
+    `Subagent ID: ${dispatchId}`,
+    instruction
+  ].join("\n");
+  return {
+    channel: run.slack.channelId,
+    thread_ts: run.slack.threadTs,
+    text: fallback,
+    blocks: [
+      {
+        type: "section",
+        text: {
+          type: "mrkdwn",
+          text: `*${escapeMrkdwn(heading)}*`
+        }
+      },
+      { type: "divider" },
+      {
+        type: "section",
+        fields: [
+          {
+            type: "mrkdwn",
+            text: `*Subagent*
+${escapeMrkdwn(roleTitle)}`
+          },
+          {
+            type: "mrkdwn",
+            text: `*Status*
+${escapeMrkdwn(statusText)}`
+          },
+          {
+            type: "mrkdwn",
+            text: `*Task*
+${escapeMrkdwn(title)}`
+          },
+          {
+            type: "mrkdwn",
+            text: `*Subagent ID*
+\`${escapeCode(dispatchId)}\``
+          }
+        ]
+      },
+      {
+        type: "context",
+        elements: [
+          {
+            type: "mrkdwn",
+            text: escapeMrkdwn(instruction)
+          }
+        ]
+      }
+    ]
+  };
+}
+function slackThreadContext(slack) {
+  if (!slack?.channelId || !slack.threadTs) {
+    return void 0;
+  }
+  return {
+    channelId: slack.channelId,
+    threadTs: slack.threadTs,
+    ...slack.channelType ? { channelType: slack.channelType } : {},
+    ...slack.messageTs ? { messageTs: slack.messageTs } : {},
+    ...slack.teamId ? { teamId: slack.teamId } : {}
+  };
+}
+function formatRoleTitle(role) {
+  const words = role.replace(/[_-]+/g, " ").trim();
+  return words ? words.charAt(0).toUpperCase() + words.slice(1) : "Subagent";
+}
+function escapeMrkdwn(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function escapeCode(value) {
+  return escapeMrkdwn(value).replace(/`/g, "'");
+}
+function formatNotifierError(error) {
+  return error instanceof Error ? error.stack ?? error.message : String(error);
+}
+
+export {
+  coalesceSlackAgentEvents,
+  routeSlackAgentEvent,
+  shouldQueueSlackAgentEvent,
+  immediateSlackTextResponse,
+  isSlackCancelMessage,
+  resolveSlackTypedApprovalAction,
+  isRunningAgentTurnError,
+  isAbortLikeError,
+  resolveSlackTurnStatusVisibilityOptions,
+  shouldInspectSlackTurnStatusVisibility,
+  recordSlackTurnActivity,
+  inspectSlackTurnStatusVisibility,
+  isSlackWaitingForHumanTurnPhase,
+  isSlackTerminalTurnPhase,
+  createSlackSubagentCompletionNotifier,
+  isSlackSubagentTerminalEvent,
+  formatDefaultSlackSubagentCompletionMessage
+};

package/dist/chunk-ELR6MQD7.js

@@ -0,0 +1,12 @@
+// src/feedback/index.ts
+import {
+  SLACK_FEEDBACK_ACTION_ID,
+  createSlackFeedbackBlock,
+  registerSlackFeedbackAction
+} from "@cuylabs/channel-slack/feedback";
+
+export {
+  SLACK_FEEDBACK_ACTION_ID,
+  createSlackFeedbackBlock,
+  registerSlackFeedbackAction
+};

package/dist/{chunk-CYEBGC6G.js → chunk-FNT4TXNQ.js}

@@ -1,11 +1,11 @@
 import {
   installSlackAgentAppSurface
-} from "./chunk-M64Z6TYL.js";
-import {
-  bolt_exports
-} from "./chunk-ANIZ5NT4.js";
+} from "./chunk-P7KK5GQG.js";
 
 // src/app.ts
+import {
+  createSlackBoltApp
+} from "@cuylabs/channel-slack/transports/http";
 async function mountSlackAgentApp(options) {
   const {
     botToken,
@@ -27,7 +27,7 @@ async function mountSlackAgentApp(options) {
     app: expressApp,
     authMode,
     routePath
-  } = await (0, bolt_exports.createSlackBoltApp)({
+  } = await createSlackBoltApp({
     signingSecret,
     path,
     botToken,

package/dist/{chunk-DHPD4XH5.js → chunk-NOVWLAVP.js}

@@ -812,16 +812,8 @@ function resolveNonNegativeInteger(value, fallback) {
   return Math.floor(value);
 }
 
-// src/shared/turn-context.ts
-import {
-  currentSlackTurnContext,
-  runWithSlackTurnContext
-} from "@cuylabs/channel-slack/core";
-
 export {
   UnsupportedSlackInteractiveRequestError,
   bridgeAgentEventsToSlack,
-  resolveSlackEventBridgeOptions,
-  currentSlackTurnContext,
-  runWithSlackTurnContext
+  resolveSlackEventBridgeOptions
 };

package/dist/{chunk-M64Z6TYL.js → chunk-P7KK5GQG.js}

@@ -1,12 +1,13 @@
 import {
   createSlackAssistantBridge
-} from "./chunk-BFUPAJON.js";
+} from "./chunk-ZDVD46RT.js";
 import {
-  feedback_exports
-} from "./chunk-VHGV66M7.js";
+  createSlackFeedbackBlock,
+  registerSlackFeedbackAction
+} from "./chunk-ELR6MQD7.js";
 import {
   createSlackChannelAdapter
-} from "./chunk-FDRQOG7Q.js";
+} from "./chunk-TIQGJ52F.js";
 
 // src/app-surface.ts
 var DEFAULT_TIMEOUT_MS = 12e4;
@@ -29,7 +30,7 @@ function installSlackAgentAppSurface(boltApp, options) {
   } = options;
   const feedbackConfig = feedbackOption === false ? void 0 : feedbackOption ?? (onFeedback ? { onFeedback } : {});
   const assistantFeedback = feedbackOption === false ? false : feedbackConfig;
-  const feedbackBlock = feedbackConfig ? (0, feedback_exports.createSlackFeedbackBlock)(feedbackConfig) : void 0;
+  const feedbackBlock = feedbackConfig ? createSlackFeedbackBlock(feedbackConfig) : void 0;
   const formatStreamError = assistantBridgeOptions.formatStreamError ?? (() => DEFAULT_STREAM_ERROR_MESSAGE);
   const formatting = assistantBridgeOptions.formatChatMarkdown;
   const channelSource = createErrorTranslatingSource(source, formatStreamError);
@@ -92,7 +93,7 @@ function installSlackAgentAppSurface(boltApp, options) {
   channelAdapter.mount(boltApp);
   if (feedbackConfig) {
     const feedbackSessionStrategy = assistantBridgeOptions.sessionStrategy ?? "thread-aware";
-    (0, feedback_exports.registerSlackFeedbackAction)(boltApp, {
+    registerSlackFeedbackAction(boltApp, {
       ...feedbackConfig,
       resolveSessionId: (ctx) => resolveFeedbackSessionId(ctx, feedbackSessionStrategy),
       onFeedback: feedbackConfig.onFeedback ?? (async (_ctx) => {