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

package/dist/chunk-NNCVHQC4.js

@@ -0,0 +1,94 @@
+// src/artifacts/final-response.ts
+import {
+  publishSlackCanvasArtifact,
+  publishSlackTextArtifact
+} from "@cuylabs/channel-slack/artifacts";
+var DEFAULT_MIN_CHARACTERS = 4e3;
+var DEFAULT_TITLE = "Agent response";
+function createSlackFinalResponseArtifactPublisher({
+  minCharacters = DEFAULT_MIN_CHARACTERS,
+  title = DEFAULT_TITLE,
+  summary,
+  channelCanvas = true,
+  fallback = "file",
+  onPublished,
+  onError
+} = {}) {
+  const configuredThreshold = Math.floor(minCharacters);
+  const threshold = Number.isFinite(configuredThreshold) && configuredThreshold > 0 ? configuredThreshold : DEFAULT_MIN_CHARACTERS;
+  return async (context) => {
+    const text = context.text.trim();
+    if (text.length < threshold) {
+      return void 0;
+    }
+    const resolvedTitle = normalizeText(await resolveValue(title, context)) ?? DEFAULT_TITLE;
+    const resolvedSummary = normalizeText(await resolveValue(summary, context));
+    let lastError;
+    try {
+      const publication = await publishSlackCanvasArtifact({
+        client: context.client,
+        channelId: context.channelId,
+        ...context.threadTs ? { threadTs: context.threadTs } : {},
+        artifact: {
+          kind: "canvas",
+          title: resolvedTitle,
+          markdown: text,
+          channelCanvas,
+          ...resolvedSummary ? { summary: resolvedSummary } : {},
+          metadata: {
+            source: "slack-final-response",
+            characterCount: text.length
+          }
+        }
+      });
+      const result = { publication };
+      await onPublished?.(result, context);
+      return result;
+    } catch (error) {
+      lastError = error;
+    }
+    if (fallback === "file") {
+      try {
+        const publication = await publishSlackTextArtifact({
+          client: context.client,
+          channelId: context.channelId,
+          ...context.threadTs ? { threadTs: context.threadTs } : {},
+          artifact: {
+            kind: "text",
+            title: resolvedTitle,
+            text,
+            filename: filenameFromTitle(resolvedTitle),
+            ...resolvedSummary ? { summary: resolvedSummary } : {},
+            metadata: {
+              source: "slack-final-response",
+              characterCount: text.length,
+              canvasFallback: true
+            }
+          }
+        });
+        const result = { publication };
+        await onPublished?.(result, context);
+        return result;
+      } catch (error) {
+        lastError = error;
+      }
+    }
+    await onError?.(lastError, context);
+    return void 0;
+  };
+}
+async function resolveValue(value, context) {
+  return typeof value === "function" ? await value(context) : value;
+}
+function normalizeText(value) {
+  const trimmed = value?.trim();
+  return trimmed ? trimmed : void 0;
+}
+function filenameFromTitle(title) {
+  const slug = title.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  return `${slug || "agent-response"}.txt`;
+}
+
+export {
+  createSlackFinalResponseArtifactPublisher
+};

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

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

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

@@ -21,6 +21,10 @@ async function bridgeAgentEventsToSlack(events, sink, options) {
   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;
@@ -54,15 +58,21 @@ async function bridgeAgentEventsToSlack(events, sink, options) {
   }
   async function updateIfNeeded(force = false) {
     if (!postedTs || !postedChannel || !fullResponse) return;
-    const shouldUpdate = force || fullResponse.length - lastUpdateLength >= options.progressiveUpdateThreshold && shouldIssueProgressiveUpdate();
+    const replacingWithArtifact = shouldReplaceFinalResponseWithArtifact();
+    const replacementTextSuppressed = replacingWithArtifact && hasCrossedFinalResponseArtifactStreamThreshold();
+    if (replacementTextSuppressed && progressiveContinuationNoticeShown && !force) {
+      return;
+    }
+    const shouldUpdate = force || !replacementTextSuppressed && fullResponse.length - lastUpdateLength >= options.progressiveUpdateThreshold && shouldIssueProgressiveUpdate();
     if (shouldUpdate) {
-      await sink.updateMessage(
-        postedChannel,
-        postedTs,
-        options.formatMessageText(fullResponse)
-      );
+      const text = formatProgressiveResponseText();
+      await sink.updateMessage(postedChannel, postedTs, text);
       lastUpdateLength = fullResponse.length;
       lastProgressiveUpdateAtMs = Date.now();
+      if (replacementTextSuppressed) {
+        progressiveContinuationNoticeShown = true;
+        finalResponseStreamTextSuppressed = true;
+      }
     }
   }
   function shouldIssueProgressiveUpdate() {
@@ -74,6 +84,41 @@ async function bridgeAgentEventsToSlack(events, sink, options) {
     }
     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;
@@ -99,6 +144,16 @@ async function bridgeAgentEventsToSlack(events, sink, options) {
   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}`;
   }
@@ -166,6 +221,38 @@ async function bridgeAgentEventsToSlack(events, sink, options) {
     }
     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;
@@ -314,6 +401,47 @@ async function bridgeAgentEventsToSlack(events, sink, options) {
       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) {
@@ -323,19 +451,25 @@ async function bridgeAgentEventsToSlack(events, sink, options) {
             await ensurePlaceholder();
           }
           break;
-        case "text-delta":
+        case "text-delta": {
           if (statusLabel) {
             statusLabel = "";
             await notifyStatus("", event);
           }
+          const previousResponseLength = fullResponse.length;
           fullResponse += event.text;
           if (options.streamingMode === "chat-stream") {
-            await appendChatStreamText(event.text);
+            await appendFinalResponseTextToChatStream(
+              event.text,
+              previousResponseLength
+            );
           } else if (options.streamingMode === "progressive") {
             await ensurePlaceholder();
-            await updateIfNeeded();
+            const crossedReplacementThreshold = shouldReplaceFinalResponseWithArtifact() && previousResponseLength <= finalResponseArtifactStreamThreshold() && hasCrossedFinalResponseArtifactStreamThreshold();
+            await updateIfNeeded(crossedReplacementThreshold);
           }
           break;
+        }
         case "text-end":
           break;
         // ── Reasoning ───────────────────────────────────────────────────
@@ -390,7 +524,7 @@ async function bridgeAgentEventsToSlack(events, sink, options) {
               id: event.toolCallId,
               title: toolTitle,
               status: "complete",
-              output: formatStreamChunkOutput(event.result)
+              output: formatToolResultOutput(event)
             });
           }
           break;
@@ -529,7 +663,7 @@ async function bridgeAgentEventsToSlack(events, sink, options) {
               id: subAgentToolTaskId(event.dispatchId, childEvent.toolCallId),
               title: `${roleTitle}: ${toolTitle}`,
               status: "complete",
-              output: formatStreamChunkOutput(childEvent.result)
+              output: formatToolResultOutput(childEvent)
             });
           } else if (childEvent.type === "tool-error") {
             const toolTitle = formatToolTitle(childEvent.toolName);
@@ -594,15 +728,20 @@ async function bridgeAgentEventsToSlack(events, sink, options) {
           }
           break;
         // ── Completion ──────────────────────────────────────────────────
-        case "complete":
+        case "complete": {
           if (!fullResponse && event.output) {
+            const previousResponseLength = fullResponse.length;
             fullResponse = event.output;
             if (options.streamingMode === "chat-stream") {
-              await appendChatStreamText(event.output);
+              await appendFinalResponseTextToChatStream(
+                event.output,
+                previousResponseLength
+              );
             }
           }
           await finalizeOpenSubAgentTasks();
           break;
+        }
         // ── Interactive requests (unsupported in Slack transport) ────────
         case "approval-request": {
           const msg = options.formatApprovalRequired(event.request);
@@ -664,17 +803,32 @@ async function bridgeAgentEventsToSlack(events, sink, options) {
           break;
       }
     }
-    const finalText = fullResponse.trim() ? options.formatMessageText(fullResponse.trim()) : "_No response_";
-    if (options.streamingMode === "chat-stream") {
-      await stopChatStream(
-        fullResponse.trim() ? void 0 : finalText,
+    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) {
@@ -702,11 +856,14 @@ function formatStreamChunkOutput(value) {
     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 normalized.length > 500 ? `${normalized.slice(0, 497).trimEnd()}...` : normalized;
+  return options.truncate && normalized.length > 500 ? `${normalized.slice(0, 497).trimEnd()}...` : normalized;
 }
 function isSlackMsgTooLongError(error) {
   if (typeof error === "object" && error !== null) {
@@ -764,7 +921,20 @@ var DEFAULT_OPTIONS = {
   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.`
+  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 {
@@ -775,6 +945,7 @@ function resolveSlackEventBridgeOptions(partial) {
     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,
@@ -799,7 +970,16 @@ function resolveSlackEventBridgeOptions(partial) {
     formatApprovalRequired: partial.formatApprovalRequired ?? DEFAULT_OPTIONS.formatApprovalRequired,
     formatHumanInputRequired: partial.formatHumanInputRequired ?? DEFAULT_OPTIONS.formatHumanInputRequired,
     ...partial.onStatusChange ? { onStatusChange: partial.onStatusChange } : {},
-    ...partial.chatStreamFinalArgs ? { chatStreamFinalArgs: partial.chatStreamFinalArgs } : {}
+    ...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) {
@@ -811,6 +991,15 @@ function resolveNonNegativeInteger(value, 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,

package/dist/{chunk-QEJ7TAZJ.js → chunk-VMVQIDNR.js}

@@ -1,9 +1,9 @@
 import {
   installSlackAgentAppSurface
-} from "./chunk-P7KK5GQG.js";
+} from "./chunk-7DUO5BMW.js";
 import {
   createSlackAssistantBridge
-} from "./chunk-ZDVD46RT.js";
+} from "./chunk-MGBNGG4D.js";
 
 // src/socket.ts
 import { createSlackSocketBoltApp } from "@cuylabs/channel-slack/transports/socket";