@cuylabs/channel-slack 0.9.0 → 0.10.0

package/dist/chunk-IAQXQESO.js

@@ -0,0 +1,1008 @@
+// src/runtime/interactive.ts
+var UnsupportedSlackInteractiveRequestError = class extends Error {
+  kind;
+  requestId;
+  constructor(kind, requestId, message) {
+    super(message);
+    this.name = "UnsupportedSlackInteractiveRequestError";
+    this.kind = kind;
+    this.requestId = requestId;
+  }
+};
+
+// src/runtime/bridge.ts
+async function bridgeSlackTurnEventsToSlack(events, sink, options) {
+  let fullResponse = "";
+  let lastUpdateLength = 0;
+  let postedTs;
+  let postedChannel;
+  let chatStream;
+  let chatStreamStopped = false;
+  let chatStreamAppendDisabled = false;
+  let chatStreamOverflowed = false;
+  let msgTooLongFallbackPosted = false;
+  let finalResponseStreamTextSuppressed = false;
+  let chatStreamContinuationNoticeAppended = false;
+  let progressiveContinuationNoticeShown = false;
+  let finalResponseArtifactContinuationNotice;
+  let statusLabel = "";
+  let lastNotifiedStatus = "";
+  let lastProgressiveUpdateAtMs;
+  const subAgentTitles = /* @__PURE__ */ new Map();
+  const openSubAgentTaskTitles = /* @__PURE__ */ new Map();
+  const taskUpdateFingerprints = /* @__PURE__ */ new Set();
+  let taskUpdateCount = 0;
+  let taskUpdateTextChars = 0;
+  let taskUpdatesOmitted = false;
+  async function notifyStatus(label, event) {
+    if (!options.onStatusChange) return;
+    const trimmed = label.trim();
+    if (trimmed === lastNotifiedStatus) return;
+    lastNotifiedStatus = trimmed;
+    try {
+      await options.onStatusChange(trimmed, event);
+    } catch {
+    }
+  }
+  async function ensurePlaceholder() {
+    if (postedTs) return;
+    const placeholder = statusLabel.trim() || "...";
+    const result = await sink.postMessage(placeholder);
+    postedTs = result.ts;
+    postedChannel = result.channel;
+    lastUpdateLength = 0;
+  }
+  async function updatePlaceholder(text) {
+    if (!postedTs || !postedChannel) return;
+    await sink.updateMessage(postedChannel, postedTs, text);
+  }
+  async function updateIfNeeded(force = false) {
+    if (!postedTs || !postedChannel || !fullResponse) return;
+    const replacingWithArtifact = shouldReplaceFinalResponseWithArtifact();
+    const replacementTextSuppressed = replacingWithArtifact && hasCrossedFinalResponseArtifactStreamThreshold();
+    if (replacementTextSuppressed && progressiveContinuationNoticeShown && !force) {
+      return;
+    }
+    const shouldUpdate = force || !replacementTextSuppressed && fullResponse.length - lastUpdateLength >= options.progressiveUpdateThreshold && shouldIssueProgressiveUpdate();
+    if (shouldUpdate) {
+      const text = formatProgressiveResponseText();
+      await sink.updateMessage(postedChannel, postedTs, text);
+      lastUpdateLength = fullResponse.length;
+      lastProgressiveUpdateAtMs = Date.now();
+      if (replacementTextSuppressed) {
+        progressiveContinuationNoticeShown = true;
+        finalResponseStreamTextSuppressed = true;
+      }
+    }
+  }
+  function shouldIssueProgressiveUpdate() {
+    if (options.progressiveUpdateIntervalMs <= 0) {
+      return true;
+    }
+    if (lastProgressiveUpdateAtMs === void 0) {
+      return true;
+    }
+    return Date.now() - lastProgressiveUpdateAtMs >= options.progressiveUpdateIntervalMs;
+  }
+  function shouldReplaceFinalResponseWithArtifact() {
+    return Boolean(
+      options.publishFinalResponseArtifact && options.finalResponseArtifactMode === "replace"
+    );
+  }
+  function finalResponseArtifactStreamThreshold() {
+    return Math.max(1, options.finalResponseArtifactStreamThreshold ?? 4e3);
+  }
+  function hasCrossedFinalResponseArtifactStreamThreshold() {
+    return fullResponse.length > finalResponseArtifactStreamThreshold();
+  }
+  function getFinalResponseArtifactContinuationNotice() {
+    if (finalResponseArtifactContinuationNotice !== void 0) {
+      return finalResponseArtifactContinuationNotice;
+    }
+    const notice = options.formatFinalResponseArtifactContinuationNotice?.({
+      text: fullResponse,
+      formattedText: options.formatMessageText(fullResponse)
+    });
+    finalResponseArtifactContinuationNotice = notice?.trim() ? notice : "";
+    return finalResponseArtifactContinuationNotice || void 0;
+  }
+  function formatTruncatedFinalResponseWithContinuationNotice() {
+    const threshold = finalResponseArtifactStreamThreshold();
+    const visibleText = fullResponse.slice(0, threshold).trimEnd();
+    const formattedText = options.formatMessageText(visibleText);
+    const notice = getFinalResponseArtifactContinuationNotice();
+    return notice ? `${formattedText}${notice}` : formattedText;
+  }
+  function formatProgressiveResponseText() {
+    if (shouldReplaceFinalResponseWithArtifact() && hasCrossedFinalResponseArtifactStreamThreshold()) {
+      return formatTruncatedFinalResponseWithContinuationNotice();
+    }
+    return options.formatMessageText(fullResponse);
+  }
+  function ensureChatStream() {
+    if (chatStream) {
+      return chatStream;
+    }
+    if (!sink.createChatStream) {
+      throw new Error(
+        "SlackResponseSink.createChatStream is required for chat-stream mode."
+      );
+    }
+    chatStream = sink.createChatStream({
+      bufferSize: options.chatStreamBufferSize
+    });
+    return chatStream;
+  }
+  async function postMsgTooLongFallback(text) {
+    if (msgTooLongFallbackPosted) {
+      return;
+    }
+    msgTooLongFallbackPosted = true;
+    const fallback = formatMsgTooLongFallback(text);
+    await sink.postMessage(fallback).catch(() => void 0);
+  }
+  function formatToolTitle(toolName) {
+    return options.formatToolTitle?.(toolName) ?? toolName;
+  }
+  function formatToolResultOutput(event) {
+    const formatted = options.formatToolResultOutput?.(event);
+    if (formatted === null) {
+      return void 0;
+    }
+    if (formatted !== void 0) {
+      return normalizeStreamChunkOutput(formatted, { truncate: false });
+    }
+    return formatStreamChunkOutput(event.result);
+  }
+  function subAgentTaskId(dispatchId) {
+    return `subagent:${dispatchId}`;
+  }
+  function subAgentToolTaskId(dispatchId, toolCallId) {
+    return `subagent:${dispatchId}:tool:${toolCallId}`;
+  }
+  function shouldRenderTaskUpdates() {
+    return options.showToolUsage && options.streamingMode === "chat-stream";
+  }
+  function formatSubAgentRole(role) {
+    const words = role.replace(/[_-]+/g, " ").trim();
+    return words ? words.charAt(0).toUpperCase() + words.slice(1) : "Subagent";
+  }
+  function inferSubAgentDepth(event) {
+    if (typeof event.depth === "number" && event.depth > 0) {
+      return event.depth;
+    }
+    if (event.agentPath) {
+      return Math.max(0, event.agentPath.split("/").filter(Boolean).length - 1);
+    }
+    return event.parentDispatchId ? 1 : 0;
+  }
+  function fallbackNestedPrefix(depth) {
+    return depth > 0 ? `Nested ${depth}` : "Nested";
+  }
+  function formatSubAgentTaskTitle(event) {
+    const roleTitle = formatSubAgentRole(event.role);
+    if (!event.parentDispatchId) {
+      return roleTitle;
+    }
+    const parentTitle = subAgentTitles.get(event.parentDispatchId);
+    const title = parentTitle ? `${parentTitle} / ${roleTitle}` : `${fallbackNestedPrefix(inferSubAgentDepth(event))} / ${roleTitle}`;
+    subAgentTitles.set(event.dispatchId, title);
+    return title;
+  }
+  function formatSubAgentStartDetails(event) {
+    return event.title && event.title !== event.role ? event.title : "Started";
+  }
+  function formatSubAgentStatusDetails(status) {
+    switch (status) {
+      case "thinking":
+      case "reasoning":
+        return options.formatReasoningUpdate();
+      case "calling-tool":
+        return "Using tools...";
+      case "waiting-approval":
+        return "Waiting for approval...";
+      case "waiting-input":
+        return "Waiting for input...";
+      case "processing":
+        return "Working...";
+      case "error":
+        return "Error";
+      default:
+        return void 0;
+    }
+  }
+  async function appendChatStreamText(text) {
+    if (chatStreamAppendDisabled) {
+      return;
+    }
+    const formatted = options.formatMessageText(text);
+    if (!formatted) {
+      return;
+    }
+    await appendToChatStream({ markdown_text: formatted });
+  }
+  async function appendFinalResponseTextToChatStream(text, previousLength) {
+    if (!shouldReplaceFinalResponseWithArtifact()) {
+      await appendChatStreamText(text);
+      return;
+    }
+    const threshold = finalResponseArtifactStreamThreshold();
+    if (previousLength >= threshold) {
+      finalResponseStreamTextSuppressed = true;
+      await appendFinalResponseArtifactContinuationNotice();
+      return;
+    }
+    const remainingVisibleCharacters = threshold - previousLength;
+    const visibleText = text.slice(0, remainingVisibleCharacters);
+    if (visibleText) {
+      await appendChatStreamText(visibleText);
+    }
+    if (text.length > remainingVisibleCharacters) {
+      finalResponseStreamTextSuppressed = true;
+      await appendFinalResponseArtifactContinuationNotice();
+    }
+  }
+  async function appendFinalResponseArtifactContinuationNotice() {
+    if (chatStreamContinuationNoticeAppended) {
+      return;
+    }
+    const notice = getFinalResponseArtifactContinuationNotice();
+    if (!notice) {
+      return;
+    }
+    chatStreamContinuationNoticeAppended = true;
+    await appendToChatStream({ markdown_text: notice });
+  }
+  async function appendChatStreamChunk(chunk) {
+    if (chatStreamAppendDisabled) {
+      return;
+    }
+    await appendToChatStream({ chunks: [chunk] });
+  }
+  async function appendToChatStream(args) {
+    try {
+      await ensureChatStream().append(args);
+    } catch (error) {
+      if (!isSlackMsgTooLongError(error)) {
+        throw error;
+      }
+      chatStreamAppendDisabled = true;
+      chatStreamOverflowed = true;
+    }
+  }
+  function truncateTaskField(value) {
+    if (value === void 0) {
+      return void 0;
+    }
+    const maxLength = Math.max(0, options.maxTaskUpdateFieldChars);
+    if (value.length <= maxLength) {
+      return value;
+    }
+    if (maxLength <= 3) {
+      return value.slice(0, maxLength);
+    }
+    return `${value.slice(0, maxLength - 3).trimEnd()}...`;
+  }
+  function normalizeTaskUpdate(chunk) {
+    const normalized = {
+      type: "task_update",
+      id: chunk.id,
+      title: chunk.title,
+      status: chunk.status
+    };
+    const details = truncateTaskField(chunk.details);
+    const output = truncateTaskField(chunk.output);
+    if (details !== void 0) {
+      normalized.details = details;
+    }
+    if (output !== void 0) {
+      normalized.output = output;
+    }
+    return normalized;
+  }
+  function taskUpdateTextLength(chunk) {
+    return chunk.title.length + (chunk.details?.length ?? 0) + (chunk.output?.length ?? 0);
+  }
+  function taskUpdateFingerprint(chunk) {
+    return JSON.stringify([
+      chunk.id,
+      chunk.title,
+      chunk.status,
+      chunk.details ?? "",
+      chunk.output ?? ""
+    ]);
+  }
+  async function appendTaskUpdatesOmittedNotice() {
+    if (taskUpdatesOmitted || taskUpdateCount >= options.maxTaskUpdates || options.maxTaskUpdateTextChars <= 0) {
+      return;
+    }
+    taskUpdatesOmitted = true;
+    const notice = {
+      type: "task_update",
+      id: "slack-task-updates-omitted",
+      title: "Additional task updates omitted",
+      status: "complete",
+      details: "Slack task timeline limit reached; see the final answer for remaining context."
+    };
+    taskUpdateCount += 1;
+    taskUpdateTextChars += taskUpdateTextLength(notice);
+    taskUpdateFingerprints.add(taskUpdateFingerprint(notice));
+    await appendChatStreamChunk(notice);
+  }
+  async function appendTaskUpdate(chunk, appendOptions = {}) {
+    const normalized = normalizeTaskUpdate(chunk);
+    const fingerprint = taskUpdateFingerprint(normalized);
+    if (taskUpdateFingerprints.has(fingerprint)) {
+      return false;
+    }
+    const textLength = taskUpdateTextLength(normalized);
+    const maxRealTaskUpdates = Math.max(0, options.maxTaskUpdates - 1);
+    if (!appendOptions.force && (taskUpdateCount >= maxRealTaskUpdates || taskUpdateTextChars + textLength > options.maxTaskUpdateTextChars)) {
+      await appendTaskUpdatesOmittedNotice();
+      return false;
+    }
+    taskUpdateFingerprints.add(fingerprint);
+    taskUpdateCount += 1;
+    taskUpdateTextChars += textLength;
+    await appendChatStreamChunk(normalized);
+    return !chatStreamAppendDisabled;
+  }
+  async function finalizeOpenSubAgentTasks() {
+    if (!shouldRenderTaskUpdates() || openSubAgentTaskTitles.size === 0) {
+      return;
+    }
+    for (const [dispatchId, title] of [...openSubAgentTaskTitles]) {
+      await appendTaskUpdate(
+        {
+          type: "task_update",
+          id: subAgentTaskId(dispatchId),
+          title,
+          status: "complete",
+          output: "Still running in the background."
+        },
+        { force: true }
+      );
+      openSubAgentTaskTitles.delete(dispatchId);
+    }
+  }
+  async function stopChatStream(markdownText, fallbackText) {
+    if (chatStreamStopped) {
+      return;
+    }
+    const stream = ensureChatStream();
+    if (chatStreamOverflowed) {
+      try {
+        await stream.stop();
+      } catch (error) {
+        if (!isSlackMsgTooLongError(error)) {
+          throw error;
+        }
+      }
+      chatStreamStopped = true;
+      await postMsgTooLongFallback(fallbackText ?? markdownText);
+      return;
+    }
+    const finalArgs = {
+      ...options.chatStreamFinalArgs ?? {}
+    };
+    if (markdownText) {
+      finalArgs.markdown_text = markdownText;
+    }
+    try {
+      await stream.stop(
+        Object.keys(finalArgs).length > 0 ? finalArgs : void 0
+      );
+      chatStreamStopped = true;
+    } catch (error) {
+      if (!isSlackMsgTooLongError(error)) {
+        throw error;
+      }
+      chatStreamStopped = true;
+      await postMsgTooLongFallback(fallbackText ?? markdownText);
+    }
+  }
+  async function publishFinalResponseArtifact(text, formattedText) {
+    if (!options.publishFinalResponseArtifact) {
+      return void 0;
+    }
+    const client = sink.artifactClient;
+    const channelId = sink.artifactTarget?.channelId;
+    if (!text || !client || !channelId) {
+      return void 0;
+    }
+    const context = {
+      text,
+      formattedText,
+      client,
+      channelId,
+      ...sink.artifactTarget?.threadTs ? { threadTs: sink.artifactTarget.threadTs } : {}
+    };
+    try {
+      const result = await options.publishFinalResponseArtifact(context);
+      return result ? { result, context } : void 0;
+    } catch (error) {
+      try {
+        await options.onFinalResponseArtifactError?.(error, context);
+      } catch {
+      }
+      return void 0;
+    }
+  }
+  function formatFinalResponseArtifactMessage(result, context) {
+    const message = options.formatFinalResponseArtifactMessage?.(result, context)?.trim();
+    if (message) {
+      return message;
+    }
+    const title = result.publication.artifact.title.trim() || "Agent response";
+    if (result.publication.method === "canvas") {
+      return `I created a Slack Canvas for the full response: ${title}`;
+    }
+    if (result.publication.method === "file") {
+      return `I uploaded the full response as a file: ${title}`;
+    }
+    return `I published the full response as a Slack artifact: ${title}`;
+  }
+  try {
+    for await (const event of events) {
+      switch (event.type) {
+        // ── Text streaming ──────────────────────────────────────────────
+        case "text-start":
+          if (options.streamingMode === "progressive") {
+            await ensurePlaceholder();
+          }
+          break;
+        case "text-delta": {
+          if (statusLabel) {
+            statusLabel = "";
+            await notifyStatus("", event);
+          }
+          const previousResponseLength = fullResponse.length;
+          fullResponse += event.text;
+          if (options.streamingMode === "chat-stream") {
+            await appendFinalResponseTextToChatStream(
+              event.text,
+              previousResponseLength
+            );
+          } else if (options.streamingMode === "progressive") {
+            await ensurePlaceholder();
+            const crossedReplacementThreshold = shouldReplaceFinalResponseWithArtifact() && previousResponseLength <= finalResponseArtifactStreamThreshold() && hasCrossedFinalResponseArtifactStreamThreshold();
+            await updateIfNeeded(crossedReplacementThreshold);
+          }
+          break;
+        }
+        case "text-end":
+          break;
+        // ── Reasoning ───────────────────────────────────────────────────
+        case "reasoning-start":
+          if (options.showReasoning) {
+            statusLabel = options.formatReasoningUpdate();
+            await notifyStatus(statusLabel, event);
+            if (options.streamingMode === "progressive") {
+              if (postedTs) {
+                await updatePlaceholder(statusLabel);
+              } else {
+                await ensurePlaceholder();
+              }
+            }
+          }
+          break;
+        case "reasoning-end":
+          statusLabel = "";
+          break;
+        // ── Tools ───────────────────────────────────────────────────────
+        case "tool-start":
+          if (options.showToolUsage) {
+            const toolTitle = formatToolTitle(event.toolName);
+            statusLabel = options.formatToolUpdate(event.toolName);
+            const toolDetails = options.formatToolDetails?.(event) ?? statusLabel;
+            await notifyStatus(statusLabel, event);
+            if (options.streamingMode === "chat-stream") {
+              await appendTaskUpdate({
+                type: "task_update",
+                id: event.toolCallId,
+                title: toolTitle,
+                status: "in_progress",
+                details: toolDetails
+              });
+            } else if (options.streamingMode === "progressive") {
+              if (!postedTs) {
+                const result = await sink.postMessage(statusLabel);
+                postedTs = result.ts;
+                postedChannel = result.channel;
+              } else if (!fullResponse) {
+                await updatePlaceholder(statusLabel);
+              }
+            }
+          }
+          break;
+        case "tool-result":
+          statusLabel = "";
+          if (options.showToolUsage && options.streamingMode === "chat-stream") {
+            const toolTitle = formatToolTitle(event.toolName);
+            await appendTaskUpdate({
+              type: "task_update",
+              id: event.toolCallId,
+              title: toolTitle,
+              status: "complete",
+              output: formatToolResultOutput(event)
+            });
+          }
+          break;
+        case "tool-error":
+          if (options.showToolUsage) {
+            const toolTitle = formatToolTitle(event.toolName);
+            statusLabel = options.formatToolError(event.toolName, event.error);
+            await notifyStatus(statusLabel, event);
+            if (options.streamingMode === "chat-stream") {
+              await appendTaskUpdate({
+                type: "task_update",
+                id: event.toolCallId,
+                title: toolTitle,
+                status: "error",
+                details: statusLabel
+              });
+            } else if (options.streamingMode === "progressive" && postedTs && !fullResponse) {
+              await updatePlaceholder(statusLabel);
+            }
+          }
+          break;
+        // ── Subagents ───────────────────────────────────────────────────
+        case "subagent-start": {
+          const roleTitle = formatSubAgentTaskTitle(event);
+          subAgentTitles.set(event.dispatchId, roleTitle);
+          const details = formatSubAgentStartDetails(event);
+          statusLabel = `${roleTitle}: ${details}`;
+          await notifyStatus(statusLabel, event);
+          if (shouldRenderTaskUpdates()) {
+            const appended = await appendTaskUpdate({
+              type: "task_update",
+              id: subAgentTaskId(event.dispatchId),
+              title: roleTitle,
+              status: "in_progress",
+              details
+            });
+            if (appended) {
+              openSubAgentTaskTitles.set(event.dispatchId, roleTitle);
+            }
+          }
+          break;
+        }
+        case "subagent-event": {
+          const roleTitle = formatSubAgentTaskTitle(event);
+          const childEvent = event.event;
+          if (childEvent.type === "approval-request") {
+            const msg = `${roleTitle}: ${options.formatApprovalRequired(
+              childEvent.request
+            )}`;
+            const handled = await options.handleInteractiveRequest?.({
+              kind: "approval",
+              request: childEvent.request,
+              fallbackText: msg
+            });
+            if (handled) {
+              statusLabel = "";
+              await notifyStatus("", event);
+              break;
+            }
+            if (options.interactiveMode === "message-and-error") {
+              if (options.streamingMode === "chat-stream") {
+                await stopChatStream(msg, msg);
+              } else if (postedTs && postedChannel) {
+                await sink.updateMessage(postedChannel, postedTs, msg);
+              } else {
+                await sink.postMessage(msg);
+              }
+              throw new UnsupportedSlackInteractiveRequestError(
+                "approval",
+                childEvent.request.id ?? "unknown",
+                msg
+              );
+            }
+            break;
+          }
+          if (childEvent.type === "human-input-request") {
+            const msg = `${roleTitle}: ${options.formatHumanInputRequired(
+              childEvent.request
+            )}`;
+            const handled = await options.handleInteractiveRequest?.({
+              kind: "human-input",
+              request: childEvent.request,
+              fallbackText: msg
+            });
+            if (handled) {
+              statusLabel = "";
+              await notifyStatus("", event);
+              break;
+            }
+            if (options.interactiveMode === "message-and-error") {
+              if (options.streamingMode === "chat-stream") {
+                await stopChatStream(msg, msg);
+              } else if (postedTs && postedChannel) {
+                await sink.updateMessage(postedChannel, postedTs, msg);
+              } else {
+                await sink.postMessage(msg);
+              }
+              throw new UnsupportedSlackInteractiveRequestError(
+                "human-input",
+                childEvent.request.id ?? "unknown",
+                msg
+              );
+            }
+            break;
+          }
+          if (childEvent.type === "approval-resolved" || childEvent.type === "human-input-resolved") {
+            statusLabel = "";
+            await notifyStatus("", event);
+            break;
+          }
+          if (childEvent.type === "status") {
+            const details = formatSubAgentStatusDetails(childEvent.status);
+            if (details) {
+              statusLabel = `${roleTitle}: ${details}`;
+              await notifyStatus(statusLabel, event);
+            }
+            break;
+          }
+          if (!options.showToolUsage || !options.showSubagentToolUsage || options.streamingMode !== "chat-stream") {
+            break;
+          }
+          if (childEvent.type === "tool-start") {
+            const toolTitle = formatToolTitle(childEvent.toolName);
+            const toolDetails = options.formatToolDetails?.(childEvent) ?? options.formatToolUpdate(childEvent.toolName);
+            await appendTaskUpdate({
+              type: "task_update",
+              id: subAgentToolTaskId(event.dispatchId, childEvent.toolCallId),
+              title: `${roleTitle}: ${toolTitle}`,
+              status: "in_progress",
+              details: toolDetails
+            });
+          } else if (childEvent.type === "tool-result") {
+            const toolTitle = formatToolTitle(childEvent.toolName);
+            await appendTaskUpdate({
+              type: "task_update",
+              id: subAgentToolTaskId(event.dispatchId, childEvent.toolCallId),
+              title: `${roleTitle}: ${toolTitle}`,
+              status: "complete",
+              output: formatToolResultOutput(childEvent)
+            });
+          } else if (childEvent.type === "tool-error") {
+            const toolTitle = formatToolTitle(childEvent.toolName);
+            await appendTaskUpdate({
+              type: "task_update",
+              id: subAgentToolTaskId(event.dispatchId, childEvent.toolCallId),
+              title: `${roleTitle}: ${toolTitle}`,
+              status: "error",
+              details: options.formatToolError(
+                childEvent.toolName,
+                childEvent.error
+              )
+            });
+          }
+          break;
+        }
+        case "subagent-complete": {
+          const roleTitle = formatSubAgentTaskTitle(event);
+          statusLabel = "";
+          await notifyStatus("", event);
+          if (shouldRenderTaskUpdates()) {
+            const wasOpen = openSubAgentTaskTitles.has(event.dispatchId);
+            const taskUpdate = {
+              type: "task_update",
+              id: subAgentTaskId(event.dispatchId),
+              title: roleTitle,
+              status: "complete"
+            };
+            if (options.showSubagentResultInTask) {
+              taskUpdate.output = formatStreamChunkOutput(event.output);
+            }
+            await appendTaskUpdate(taskUpdate, { force: wasOpen });
+            openSubAgentTaskTitles.delete(event.dispatchId);
+          }
+          break;
+        }
+        case "subagent-error": {
+          const roleTitle = formatSubAgentTaskTitle(event);
+          statusLabel = `${roleTitle}: ${event.error}`;
+          await notifyStatus(statusLabel, event);
+          if (shouldRenderTaskUpdates()) {
+            const wasOpen = openSubAgentTaskTitles.has(event.dispatchId);
+            await appendTaskUpdate(
+              {
+                type: "task_update",
+                id: subAgentTaskId(event.dispatchId),
+                title: roleTitle,
+                status: "error",
+                details: event.error
+              },
+              { force: wasOpen }
+            );
+            openSubAgentTaskTitles.delete(event.dispatchId);
+          }
+          break;
+        }
+        // ── Status ──────────────────────────────────────────────────────
+        case "status":
+          if ((event.status === "thinking" || event.status === "reasoning") && options.showReasoning) {
+            statusLabel = options.formatReasoningUpdate();
+            await notifyStatus(statusLabel, event);
+          }
+          break;
+        // ── Completion ──────────────────────────────────────────────────
+        case "complete": {
+          if (!fullResponse && event.output) {
+            const previousResponseLength = fullResponse.length;
+            fullResponse = event.output;
+            if (options.streamingMode === "chat-stream") {
+              await appendFinalResponseTextToChatStream(
+                event.output,
+                previousResponseLength
+              );
+            }
+          }
+          await finalizeOpenSubAgentTasks();
+          break;
+        }
+        // ── Interactive requests (unsupported in Slack transport) ────────
+        case "approval-request": {
+          const msg = options.formatApprovalRequired(event.request);
+          const handled = await options.handleInteractiveRequest?.({
+            kind: "approval",
+            request: event.request,
+            fallbackText: msg
+          });
+          if (handled) {
+            statusLabel = "";
+            await notifyStatus("", event);
+            break;
+          }
+          if (options.interactiveMode === "message-and-error") {
+            if (options.streamingMode === "chat-stream") {
+              await stopChatStream(msg, msg);
+            } else if (postedTs && postedChannel) {
+              await sink.updateMessage(postedChannel, postedTs, msg);
+            } else {
+              await sink.postMessage(msg);
+            }
+            throw new UnsupportedSlackInteractiveRequestError(
+              "approval",
+              event.request.id ?? "unknown",
+              msg
+            );
+          }
+          break;
+        }
+        case "human-input-request": {
+          const msg = options.formatHumanInputRequired(event.request);
+          const handled = await options.handleInteractiveRequest?.({
+            kind: "human-input",
+            request: event.request,
+            fallbackText: msg
+          });
+          if (handled) {
+            statusLabel = "";
+            await notifyStatus("", event);
+            break;
+          }
+          if (options.interactiveMode === "message-and-error") {
+            if (options.streamingMode === "chat-stream") {
+              await stopChatStream(msg, msg);
+            } else if (postedTs && postedChannel) {
+              await sink.updateMessage(postedChannel, postedTs, msg);
+            } else {
+              await sink.postMessage(msg);
+            }
+            throw new UnsupportedSlackInteractiveRequestError(
+              "human-input",
+              event.request.id ?? "unknown",
+              msg
+            );
+          }
+          break;
+        }
+        default:
+          break;
+      }
+    }
+    const rawFinalText = fullResponse.trim();
+    let finalText = rawFinalText ? options.formatMessageText(rawFinalText) : "_No response_";
+    let publishedArtifact;
+    if (shouldReplaceFinalResponseWithArtifact()) {
+      publishedArtifact = await publishFinalResponseArtifact(
+        rawFinalText,
+        finalText
+      );
+      if (publishedArtifact) {
+        finalText = formatFinalResponseArtifactMessage(
+          publishedArtifact.result,
+          publishedArtifact.context
+        );
+      }
+    }
+    if (options.streamingMode === "chat-stream") {
+      const chatStreamFinalText = publishedArtifact || !rawFinalText || finalResponseStreamTextSuppressed ? finalText : void 0;
+      await stopChatStream(chatStreamFinalText, finalText);
+    } else if (postedTs && postedChannel) {
+      await sink.updateMessage(postedChannel, postedTs, finalText);
+    } else {
+      await sink.postMessage(finalText);
+    }
+    if (!shouldReplaceFinalResponseWithArtifact()) {
+      await publishFinalResponseArtifact(rawFinalText, finalText);
+    }
+    return fullResponse;
+  } catch (error) {
+    if (error instanceof UnsupportedSlackInteractiveRequestError) {
+      throw error;
+    }
+    if (options.streamingMode === "chat-stream") {
+      if (chatStream && !chatStreamStopped) {
+        await stopChatStream(
+          void 0,
+          fullResponse.trim() ? options.formatMessageText(fullResponse.trim()) : void 0
+        ).catch(() => void 0);
+      }
+    } else if (fullResponse && postedTs && postedChannel) {
+      await sink.updateMessage(
+        postedChannel,
+        postedTs,
+        options.formatMessageText(fullResponse)
+      ).catch(() => void 0);
+    }
+    throw error;
+  }
+}
+function formatStreamChunkOutput(value) {
+  if (value === void 0 || value === null) {
+    return void 0;
+  }
+  const text = typeof value === "string" ? value : safeJsonStringify(value) ?? String(value);
+  return normalizeStreamChunkOutput(text, { truncate: true });
+}
+function normalizeStreamChunkOutput(text, options) {
+  const normalized = text.trim();
+  if (!normalized) {
+    return void 0;
+  }
+  return options.truncate && normalized.length > 500 ? `${normalized.slice(0, 497).trimEnd()}...` : normalized;
+}
+function isSlackMsgTooLongError(error) {
+  if (typeof error === "object" && error !== null) {
+    const record = error;
+    if (record.code === "msg_too_long" || record.error === "msg_too_long") {
+      return true;
+    }
+    const data = record.data;
+    if (typeof data === "object" && data !== null) {
+      const dataRecord = data;
+      if (dataRecord.error === "msg_too_long" || dataRecord.code === "msg_too_long") {
+        return true;
+      }
+    }
+  }
+  return error instanceof Error && error.message.includes("msg_too_long");
+}
+function formatMsgTooLongFallback(text) {
+  const intro = "Slack could not finalize the streamed task timeline because it was too large. Task details were truncated.";
+  const normalized = text?.trim();
+  if (!normalized) {
+    return intro;
+  }
+  const maxLength = 8e3;
+  const separator = "\n\n";
+  const available = Math.max(0, maxLength - intro.length - separator.length);
+  const body = normalized.length > available ? `${normalized.slice(0, Math.max(0, available - 3)).trimEnd()}...` : normalized;
+  return `${intro}${separator}${body}`;
+}
+function safeJsonStringify(value) {
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return void 0;
+  }
+}
+
+// src/runtime/options.ts
+var DEFAULT_OPTIONS = {
+  showReasoning: false,
+  showToolUsage: true,
+  showSubagentToolUsage: false,
+  showSubagentResultInTask: false,
+  formatToolTitle: (toolName) => toolName,
+  formatToolUpdate: (toolName) => `\u{1F50D} Using tool: ${toolName}...`,
+  formatToolError: (toolName, _error) => `\u26A0\uFE0F Tool ${toolName} encountered an error`,
+  formatReasoningUpdate: () => "Thinking...",
+  formatMessageText: (text) => text,
+  streamingMode: "progressive",
+  progressiveUpdateThreshold: 150,
+  progressiveUpdateIntervalMs: 3e3,
+  chatStreamBufferSize: 256,
+  maxTaskUpdates: 200,
+  maxTaskUpdateTextChars: 2e4,
+  maxTaskUpdateFieldChars: 500,
+  interactiveMode: "message-and-error",
+  formatApprovalRequired: (request) => `This turn requires approval for "${request.tool}", but in-channel approval is not configured for this Slack host.`,
+  formatHumanInputRequired: (request) => `This turn is waiting for input: ${request.title}. In-channel human input is not configured for this Slack host.`,
+  finalResponseArtifactMode: "supplemental",
+  finalResponseArtifactStreamThreshold: 4e3,
+  formatFinalResponseArtifactContinuationNotice: () => "\n\nFull response is long. I will publish the complete answer as a Slack artifact when it finishes.",
+  formatFinalResponseArtifactMessage: (result) => {
+    const title = result.publication.artifact.title.trim() || "Agent response";
+    if (result.publication.method === "canvas") {
+      return `I created a Slack Canvas for the full response: ${title}`;
+    }
+    if (result.publication.method === "file") {
+      return `I uploaded the full response as a file: ${title}`;
+    }
+    return `I published the full response as a Slack artifact: ${title}`;
+  }
+};
+function resolveSlackEventBridgeOptions(partial) {
+  return {
+    showReasoning: partial.showReasoning ?? DEFAULT_OPTIONS.showReasoning,
+    showToolUsage: partial.showToolUsage ?? DEFAULT_OPTIONS.showToolUsage,
+    showSubagentToolUsage: partial.showSubagentToolUsage ?? DEFAULT_OPTIONS.showSubagentToolUsage,
+    showSubagentResultInTask: partial.showSubagentResultInTask ?? DEFAULT_OPTIONS.showSubagentResultInTask,
+    formatToolTitle: partial.formatToolTitle ?? DEFAULT_OPTIONS.formatToolTitle,
+    formatToolUpdate: partial.formatToolUpdate ?? DEFAULT_OPTIONS.formatToolUpdate,
+    ...partial.formatToolDetails ? { formatToolDetails: partial.formatToolDetails } : {},
+    ...partial.formatToolResultOutput ? { formatToolResultOutput: partial.formatToolResultOutput } : {},
+    formatToolError: partial.formatToolError ?? DEFAULT_OPTIONS.formatToolError,
+    formatReasoningUpdate: partial.formatReasoningUpdate ?? DEFAULT_OPTIONS.formatReasoningUpdate,
+    formatMessageText: partial.formatMessageText ?? DEFAULT_OPTIONS.formatMessageText,
+    streamingMode: partial.streamingMode ?? DEFAULT_OPTIONS.streamingMode,
+    progressiveUpdateThreshold: partial.progressiveUpdateThreshold ?? DEFAULT_OPTIONS.progressiveUpdateThreshold,
+    progressiveUpdateIntervalMs: partial.progressiveUpdateIntervalMs ?? DEFAULT_OPTIONS.progressiveUpdateIntervalMs,
+    chatStreamBufferSize: partial.chatStreamBufferSize ?? DEFAULT_OPTIONS.chatStreamBufferSize,
+    maxTaskUpdates: resolveNonNegativeInteger(
+      partial.maxTaskUpdates,
+      DEFAULT_OPTIONS.maxTaskUpdates
+    ),
+    maxTaskUpdateTextChars: resolveNonNegativeInteger(
+      partial.maxTaskUpdateTextChars,
+      DEFAULT_OPTIONS.maxTaskUpdateTextChars
+    ),
+    maxTaskUpdateFieldChars: resolveNonNegativeInteger(
+      partial.maxTaskUpdateFieldChars,
+      DEFAULT_OPTIONS.maxTaskUpdateFieldChars
+    ),
+    interactiveMode: partial.interactiveMode ?? DEFAULT_OPTIONS.interactiveMode,
+    ...partial.handleInteractiveRequest ? { handleInteractiveRequest: partial.handleInteractiveRequest } : {},
+    formatApprovalRequired: partial.formatApprovalRequired ?? DEFAULT_OPTIONS.formatApprovalRequired,
+    formatHumanInputRequired: partial.formatHumanInputRequired ?? DEFAULT_OPTIONS.formatHumanInputRequired,
+    ...partial.onStatusChange ? { onStatusChange: partial.onStatusChange } : {},
+    ...partial.chatStreamFinalArgs ? { chatStreamFinalArgs: partial.chatStreamFinalArgs } : {},
+    ...partial.publishFinalResponseArtifact ? { publishFinalResponseArtifact: partial.publishFinalResponseArtifact } : {},
+    finalResponseArtifactMode: partial.finalResponseArtifactMode ?? DEFAULT_OPTIONS.finalResponseArtifactMode,
+    finalResponseArtifactStreamThreshold: resolvePositiveInteger(
+      partial.finalResponseArtifactStreamThreshold,
+      DEFAULT_OPTIONS.finalResponseArtifactStreamThreshold ?? 4e3
+    ),
+    formatFinalResponseArtifactContinuationNotice: partial.formatFinalResponseArtifactContinuationNotice ?? DEFAULT_OPTIONS.formatFinalResponseArtifactContinuationNotice,
+    formatFinalResponseArtifactMessage: partial.formatFinalResponseArtifactMessage ?? DEFAULT_OPTIONS.formatFinalResponseArtifactMessage,
+    ...partial.onFinalResponseArtifactError ? { onFinalResponseArtifactError: partial.onFinalResponseArtifactError } : {}
+  };
+}
+function resolveNonNegativeInteger(value, fallback) {
+  if (value === void 0) {
+    return fallback;
+  }
+  if (!Number.isFinite(value) || value < 0) {
+    return fallback;
+  }
+  return Math.floor(value);
+}
+function resolvePositiveInteger(value, fallback) {
+  if (value === void 0) {
+    return fallback;
+  }
+  if (!Number.isFinite(value) || value < 1) {
+    return fallback;
+  }
+  return Math.floor(value);
+}
+
+export {
+  UnsupportedSlackInteractiveRequestError,
+  bridgeSlackTurnEventsToSlack,
+  resolveSlackEventBridgeOptions
+};