@cuylabs/channel-slack-agent-core 0.5.1 → 0.7.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-JMLB7A2V.js → chunk-DJPKRKGP.js}

@@ -1,11 +1,11 @@
 import {
   createSlackAssistantBridge
-} from "./chunk-BFUPAJON.js";
-import {
-  bolt_exports
-} from "./chunk-ANIZ5NT4.js";
+} from "./chunk-MGBNGG4D.js";
 
 // src/express-assistant.ts
+import {
+  createSlackBoltApp
+} from "@cuylabs/channel-slack/transports/http";
 async function mountSlackAssistantAgent(options) {
   const {
     botToken,
@@ -29,7 +29,7 @@ async function mountSlackAssistantAgent(options) {
     app: expressApp,
     authMode,
     routePath
-  } = await (0, bolt_exports.createSlackBoltApp)({
+  } = await createSlackBoltApp({
     signingSecret,
     path,
     botToken,

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-FDRQOG7Q.js → chunk-FQWFB54C.js}

@@ -1,22 +1,25 @@
+import {
+  UnsupportedSlackInteractiveRequestError,
+  bridgeAgentEventsToSlack,
+  resolveSlackEventBridgeOptions
+} from "./chunk-TMADMHBN.js";
+
+// src/adapter/adapter.ts
+import { withinScope } from "@cuylabs/agent-core";
 import {
   extractSlackAuthContext,
   extractSlackUserIdentity,
   isProcessableMessage,
   parseSlackMentionActivity,
   parseSlackMessageActivity,
-  resolveSlackMessageFormatter
-} from "./chunk-GNXWTKQ6.js";
-import {
-  UnsupportedSlackInteractiveRequestError,
-  bridgeAgentEventsToSlack,
-  resolveSlackEventBridgeOptions,
+  resolveSlackMessageFormatter,
   runWithSlackTurnContext
-} from "./chunk-DHPD4XH5.js";
-
-// src/shared/session.ts
-import { resolveThreadAwareSlackSessionId } from "@cuylabs/channel-slack/core";
+} from "@cuylabs/channel-slack/core";
 
 // src/adapter/session-map.ts
+import {
+  resolveThreadAwareSlackSessionId
+} from "@cuylabs/channel-slack/core";
 function createSlackSessionMap(options) {
   const strategy = options.sessionStrategy ?? "thread-aware";
   if (strategy === "custom") {
@@ -61,9 +64,6 @@ function createSlackSessionMap(options) {
   };
 }
 
-// src/adapter/adapter.ts
-import { withinScope } from "@cuylabs/agent-core";
-
 // src/adapter/sink.ts
 function buildThreadPayload(info, respondInThread) {
   if (!respondInThread || info.channelType === "dm") return {};
@@ -73,6 +73,11 @@ function buildThreadPayload(info, respondInThread) {
 function buildResponseSink(say, client, info, respondInThread, chatStreamStartArgs, sayStream) {
   const threadPayload = buildThreadPayload(info, respondInThread);
   return {
+    artifactClient: client,
+    artifactTarget: {
+      channelId: info.channelId,
+      ...threadPayload.thread_ts ? { threadTs: threadPayload.thread_ts } : {}
+    },
     async postMessage(text) {
       const result = await say({ text, ...threadPayload });
       const response = result;
@@ -167,6 +172,7 @@ function createSlackChannelAdapter(options) {
       formatToolTitle: options.formatToolTitle,
       formatToolUpdate: options.formatToolUpdate,
       formatToolDetails: options.formatToolDetails,
+      formatToolResultOutput: options.formatToolResultOutput,
       formatToolError: options.formatToolError,
       formatReasoningUpdate: options.formatReasoningUpdate,
       interactiveMode: options.interactiveMode,
@@ -180,7 +186,13 @@ function createSlackChannelAdapter(options) {
       maxTaskUpdates: options.maxTaskUpdates,
       maxTaskUpdateTextChars: options.maxTaskUpdateTextChars,
       maxTaskUpdateFieldChars: options.maxTaskUpdateFieldChars,
-      chatStreamFinalArgs: options.chatStreamFinalArgs
+      chatStreamFinalArgs: options.chatStreamFinalArgs,
+      publishFinalResponseArtifact: options.publishFinalResponseArtifact,
+      finalResponseArtifactMode: options.finalResponseArtifactMode,
+      finalResponseArtifactStreamThreshold: options.finalResponseArtifactStreamThreshold,
+      formatFinalResponseArtifactContinuationNotice: options.formatFinalResponseArtifactContinuationNotice,
+      formatFinalResponseArtifactMessage: options.formatFinalResponseArtifactMessage,
+      onFinalResponseArtifactError: options.onFinalResponseArtifactError
     }
   );
   const timeout = options.timeout ?? 12e4;
@@ -465,7 +477,6 @@ function formatErrorForLog(error) {
 }
 
 export {
-  resolveThreadAwareSlackSessionId,
   createSlackSessionMap,
   createSlackChannelAdapter
 };