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

package/dist/{chunk-ZDVD46RT.js → chunk-7YZWCSML.js}

@@ -7,10 +7,11 @@ import {
   UnsupportedSlackInteractiveRequestError,
   bridgeAgentEventsToSlack,
   resolveSlackEventBridgeOptions
-} from "./chunk-NOVWLAVP.js";
+} from "./chunk-TMADMHBN.js";
 
 // src/assistant/bridge.ts
 import { Assistant } from "@slack/bolt";
+import { resolveSlackTurnCancelActionId as resolveSlackTurnCancelActionId2 } from "@cuylabs/channel-slack/turn-controls";
 
 // src/assistant/options.ts
 var DEFAULT_INITIAL_REPLY = "Hi, how can I help?";
@@ -239,6 +240,11 @@ function createAssistantSink(params) {
     return stream;
   }
   return {
+    artifactClient: params.client,
+    artifactTarget: {
+      channelId: params.channel,
+      threadTs: params.threadTs
+    },
     async postMessage() {
       throw new Error(
         "Assistant bridge uses chat-stream mode and does not support postMessage."
@@ -289,7 +295,7 @@ function createAssistantInteractiveResponder(params) {
 
 // src/assistant/lifecycle/user-message.ts
 function createUserMessageHandler(deps) {
-  const { options, feedbackBlock, sessionStrategy } = deps;
+  const { options, feedbackBlock, sessionStrategy, turnControlController } = deps;
   const taskDisplayMode = options.taskDisplayMode ?? "timeline";
   const messageFormatter = resolveSlackMessageFormatter(
     options.formatChatMarkdown ?? {}
@@ -427,6 +433,7 @@ function createUserMessageHandler(deps) {
         ...options.formatToolTitle ? { formatToolTitle: options.formatToolTitle } : {},
         ...options.formatToolUpdate ? { formatToolUpdate: options.formatToolUpdate } : {},
         ...options.formatToolDetails ? { formatToolDetails: options.formatToolDetails } : {},
+        ...options.formatToolResultOutput ? { formatToolResultOutput: options.formatToolResultOutput } : {},
         ...options.formatToolError ? { formatToolError: options.formatToolError } : {},
         ...options.formatReasoningUpdate ? { formatReasoningUpdate: options.formatReasoningUpdate } : {},
         ...options.chatStreamBufferSize !== void 0 ? { chatStreamBufferSize: options.chatStreamBufferSize } : {},
@@ -434,6 +441,22 @@ function createUserMessageHandler(deps) {
         ...options.maxTaskUpdateTextChars !== void 0 ? { maxTaskUpdateTextChars: options.maxTaskUpdateTextChars } : {},
         ...options.maxTaskUpdateFieldChars !== void 0 ? { maxTaskUpdateFieldChars: options.maxTaskUpdateFieldChars } : {},
         ...chatStreamFinalArgs ? { chatStreamFinalArgs } : {},
+        ...options.publishFinalResponseArtifact ? {
+          publishFinalResponseArtifact: options.publishFinalResponseArtifact
+        } : {},
+        ...options.finalResponseArtifactMode ? { finalResponseArtifactMode: options.finalResponseArtifactMode } : {},
+        ...options.finalResponseArtifactStreamThreshold !== void 0 ? {
+          finalResponseArtifactStreamThreshold: options.finalResponseArtifactStreamThreshold
+        } : {},
+        ...options.formatFinalResponseArtifactContinuationNotice ? {
+          formatFinalResponseArtifactContinuationNotice: options.formatFinalResponseArtifactContinuationNotice
+        } : {},
+        ...options.formatFinalResponseArtifactMessage ? {
+          formatFinalResponseArtifactMessage: options.formatFinalResponseArtifactMessage
+        } : {},
+        ...options.onFinalResponseArtifactError ? {
+          onFinalResponseArtifactError: options.onFinalResponseArtifactError
+        } : {},
         formatMessageText: messageFormatter,
         onStatusChange: async (label, event) => {
           const update = await resolveStatusUpdate(
@@ -475,6 +498,17 @@ function createUserMessageHandler(deps) {
       });
       const abortController = new AbortController();
       timeoutId = timeoutMs > 0 ? setTimeout(() => abortController.abort(), timeoutMs) : void 0;
+      const cancelControl = turnControlController?.createCancelControl({
+        abortController,
+        channel,
+        client,
+        logger: diagnosticsLogger,
+        sessionId,
+        ...teamId ? { teamId } : {},
+        threadTs,
+        userId: userId ?? "unknown"
+      });
+      cancelControl?.show("turn-start");
       await runWithSlackTurnContext(
         {
           slackActivity: parsed,
@@ -511,6 +545,7 @@ function createUserMessageHandler(deps) {
             const translated = (async function* () {
               try {
                 for await (const event of events) {
+                  cancelControl?.sync(event);
                   if (event.type === "error") {
                     translatedError = toError(
                       event.error
@@ -539,6 +574,8 @@ ${formatStreamError(translatedError)}`
 ${formatStreamError(translatedError)}`
                 };
                 yield { type: "complete" };
+              } finally {
+                cancelControl?.clear("turn-finished");
               }
             })();
             const finalText = await bridgeAgentEventsToSlack(
@@ -595,6 +632,213 @@ ${formatStreamError(translatedError)}`
   };
 }
 
+// src/assistant/turn-controls.ts
+import { randomUUID } from "crypto";
+import {
+  createSlackTurnCancelMessage,
+  registerSlackTurnCancelAction,
+  resolveSlackTurnCancelActionId
+} from "@cuylabs/channel-slack/turn-controls";
+function createSlackAssistantTurnControlController(options) {
+  const resolvedCancelOptions = resolveCancelOptions(options);
+  if (!resolvedCancelOptions) {
+    return void 0;
+  }
+  const cancelOptions = resolvedCancelOptions;
+  const actionId = resolveSlackTurnCancelActionId(cancelOptions.actionId);
+  const activeControls = /* @__PURE__ */ new Map();
+  function install(app) {
+    registerSlackTurnCancelAction(app, {
+      actionId,
+      onCancel: (context) => handleCancelAction(context)
+    });
+  }
+  function createCancelControl(controlOptions) {
+    const control = {
+      abortController: controlOptions.abortController,
+      channel: controlOptions.channel,
+      client: controlOptions.client,
+      controlId: randomUUID(),
+      logger: controlOptions.logger,
+      pending: Promise.resolve(),
+      sessionId: controlOptions.sessionId,
+      ...controlOptions.teamId ? { teamId: controlOptions.teamId } : {},
+      threadTs: controlOptions.threadTs,
+      userId: controlOptions.userId,
+      visible: false
+    };
+    activeControls.set(control.controlId, control);
+    return {
+      show(reason) {
+        showCancelControl(control, reason);
+      },
+      clear(reason) {
+        clearCancelControl(control, reason);
+      },
+      sync(event) {
+        syncCancelControlForEvent(control, event);
+      }
+    };
+  }
+  async function handleCancelAction(context) {
+    const control = activeControls.get(context.controlId);
+    if (!control) {
+      await context.deleteMessage().catch(() => void 0);
+      await acknowledge(context, cancelOptions.alreadyCompletedAck);
+      return;
+    }
+    if (context.userId !== control.userId) {
+      await acknowledge(context, cancelOptions.unauthorizedAck);
+      return;
+    }
+    clearCancelControl(control, "button-cancel");
+    activeControls.delete(control.controlId);
+    if (!control.abortController.signal.aborted) {
+      control.abortController.abort(createSlackTurnCancelledError());
+    }
+    await cancelOptions.onCancel?.({
+      controlId: control.controlId,
+      sessionId: control.sessionId,
+      channelId: control.channel,
+      threadTs: control.threadTs,
+      userId: control.userId,
+      ...control.teamId ? { teamId: control.teamId } : {}
+    });
+    await acknowledge(context, cancelOptions.canceledAck);
+  }
+  function showCancelControl(control, reason) {
+    if (control.visible || control.abortController.signal.aborted) {
+      return;
+    }
+    control.visible = true;
+    enqueueControlUpdate(control, "show", reason, async () => {
+      const message = createSlackTurnCancelMessage({
+        actionId,
+        controlId: control.controlId,
+        messageText: cancelOptions.messageText,
+        buttonText: cancelOptions.buttonText,
+        sessionId: control.sessionId
+      });
+      if (control.target) {
+        await control.client.chat.update({
+          channel: control.target.channel,
+          ts: control.target.ts,
+          text: message.text,
+          blocks: message.blocks
+        });
+        return;
+      }
+      const response = await control.client.chat.postMessage({
+        channel: control.channel,
+        thread_ts: control.threadTs,
+        text: message.text,
+        blocks: message.blocks
+      });
+      if (response.channel && response.ts) {
+        control.target = { channel: response.channel, ts: response.ts };
+      }
+    });
+  }
+  function clearCancelControl(control, reason) {
+    const terminal = isTerminalClearReason(reason);
+    if (terminal) {
+      activeControls.delete(control.controlId);
+    }
+    if (!control.visible) {
+      return;
+    }
+    control.visible = false;
+    enqueueControlUpdate(control, "clear", reason, async () => {
+      if (!control.target) {
+        return;
+      }
+      const target = control.target;
+      control.target = void 0;
+      await control.client.chat.delete({
+        channel: target.channel,
+        ts: target.ts
+      });
+    });
+  }
+  function syncCancelControlForEvent(control, event) {
+    switch (event.type) {
+      case "text-start":
+      case "text-delta":
+      case "text-end":
+        if (cancelOptions.visibleWhen === "before-output") {
+          clearCancelControl(control, "streaming-started");
+        }
+        break;
+      case "reasoning-start":
+      case "reasoning-delta":
+      case "reasoning-end":
+      case "tool-start":
+      case "approval-request":
+      case "human-input-request":
+        showCancelControl(control, event.type);
+        break;
+      case "status":
+        if (isWaitingForAgentStatus(event.status)) {
+          showCancelControl(control, `status:${event.status}`);
+        } else if (event.status === "idle" || event.status === "error") {
+          clearCancelControl(control, `status:${event.status}`);
+        }
+        break;
+      case "complete":
+        clearCancelControl(control, "turn-finished");
+        break;
+      case "error":
+        clearCancelControl(control, "turn-error");
+        break;
+      default:
+        break;
+    }
+  }
+  function enqueueControlUpdate(control, action, reason, update) {
+    control.pending = control.pending.then(update);
+    control.pending = control.pending.catch((error) => {
+      control.logger.warn?.("Slack turn cancel control update failed", {
+        action,
+        controlId: control.controlId,
+        error: formatErrorForLog(error),
+        reason,
+        sessionId: control.sessionId
+      });
+    });
+  }
+  async function acknowledge(context, text) {
+    if (text === false) {
+      return;
+    }
+    await context.acknowledgeEphemeral(text ?? "Canceled the running request.");
+  }
+  return { install, createCancelControl };
+}
+function resolveCancelOptions(options) {
+  if (!options?.cancel) {
+    return void 0;
+  }
+  const input = options.cancel === true ? {} : options.cancel;
+  return {
+    ...input,
+    visibleWhen: input.visibleWhen ?? "before-output",
+    canceledAck: input.canceledAck ?? "Canceled the running request.",
+    alreadyCompletedAck: input.alreadyCompletedAck ?? "That request is no longer running.",
+    unauthorizedAck: input.unauthorizedAck ?? "Only the user who started this request can cancel it."
+  };
+}
+function isWaitingForAgentStatus(status) {
+  return status === "processing" || status === "thinking" || status === "reasoning" || status === "calling-tool" || status === "waiting-approval" || status === "waiting-input";
+}
+function isTerminalClearReason(reason) {
+  return reason === "streaming-started" || reason === "turn-finished" || reason === "turn-error" || reason === "button-cancel";
+}
+function createSlackTurnCancelledError() {
+  return Object.assign(new Error("Slack turn was cancelled by the user."), {
+    category: "cancelled"
+  });
+}
+
 // src/assistant/bridge.ts
 import { createSlackAssistantThreadContextStore } from "@cuylabs/channel-slack/assistant";
 function createSlackAssistantBridge(options) {
@@ -612,13 +856,20 @@ function createSlackAssistantBridge(options) {
   const feedbackConfig = options.feedback === false ? void 0 : options.feedback ?? {};
   const feedbackBlock = feedbackConfig ? createSlackFeedbackBlock(feedbackConfig) : void 0;
   const feedbackActionId = feedbackConfig?.actionId ?? SLACK_FEEDBACK_ACTION_ID;
+  const turnControlController = createSlackAssistantTurnControlController(
+    options.turnControls
+  );
+  const turnCancelActionId = turnControlController ? resolveSlackTurnCancelActionId2(
+    resolveTurnCancelActionIdOption(options.turnControls)
+  ) : void 0;
   const threadStarted = createThreadStartedHandler(options);
   const threadContextChanged = createThreadContextChangedHandler();
   const threadContextStore = options.threadContextStore ?? createSlackAssistantThreadContextStore();
   const userMessage = createUserMessageHandler({
     options,
     feedbackBlock,
-    sessionStrategy
+    sessionStrategy,
+    ...turnControlController ? { turnControlController } : {}
   });
   const config = {
     threadStarted,
@@ -640,13 +891,21 @@ function createSlackAssistantBridge(options) {
         })
       });
     }
+    turnControlController?.install(app);
   }
   return {
     assistant,
     install,
-    ...feedbackConfig ? { feedbackActionId } : {}
+    ...feedbackConfig ? { feedbackActionId } : {},
+    ...turnCancelActionId ? { turnCancelActionId } : {}
   };
 }
+function resolveTurnCancelActionIdOption(options) {
+  if (!options || !options.cancel) {
+    return void 0;
+  }
+  return typeof options.cancel === "object" ? options.cancel.actionId : void 0;
+}
 
 // src/assistant/index.ts
 import {

package/dist/chunk-C7CHMYV6.js

@@ -0,0 +1,226 @@
+// src/views/controller.ts
+import { registerSlackViewWorkflow } from "@cuylabs/channel-slack/views";
+
+// src/views/state.ts
+function extractSlackAgentViewStateValues(viewOrState) {
+  const state = isRecord(viewOrState) ? isRecord(viewOrState.state) ? viewOrState.state : viewOrState : {};
+  const rawValues = isRecord(state.values) ? state.values : {};
+  const values = {};
+  for (const [blockId, rawActions] of Object.entries(rawValues)) {
+    if (!isRecord(rawActions)) {
+      continue;
+    }
+    const actions = {};
+    for (const [actionId, rawAction] of Object.entries(rawActions)) {
+      actions[actionId] = extractSlackAgentViewActionValue(rawAction);
+    }
+    values[blockId] = actions;
+  }
+  return values;
+}
+function readSlackAgentViewStateValue(valuesOrView, blockId, actionId) {
+  const values = looksLikeExtractedStateValues(valuesOrView) ? valuesOrView : extractSlackAgentViewStateValues(valuesOrView);
+  return values[blockId]?.[actionId];
+}
+function extractSlackAgentViewActionValue(rawAction) {
+  if (!isRecord(rawAction)) {
+    return void 0;
+  }
+  if ("value" in rawAction && typeof rawAction.value !== "undefined") {
+    return normalizeValue(rawAction.value);
+  }
+  if (isRecord(rawAction.selected_option)) {
+    return readOptionValue(rawAction.selected_option);
+  }
+  if (Array.isArray(rawAction.selected_options)) {
+    return rawAction.selected_options.map(readOptionValue).filter(isString);
+  }
+  for (const field of [
+    "selected_user",
+    "selected_users",
+    "selected_channel",
+    "selected_channels",
+    "selected_conversation",
+    "selected_conversations",
+    "selected_date",
+    "selected_time",
+    "selected_date_time"
+  ]) {
+    const value = rawAction[field];
+    if (typeof value !== "undefined") {
+      return normalizeValue(value);
+    }
+  }
+  if (typeof rawAction.checked === "boolean") {
+    return rawAction.checked;
+  }
+  return rawAction;
+}
+function readOptionValue(option) {
+  if (!isRecord(option)) {
+    return "";
+  }
+  if (typeof option.value === "string") {
+    return option.value;
+  }
+  const text = option.text;
+  if (isRecord(text) && typeof text.text === "string") {
+    return text.text;
+  }
+  return "";
+}
+function normalizeValue(value) {
+  if (typeof value === "string" || typeof value === "boolean" || typeof value === "number") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.filter(isString);
+  }
+  return isRecord(value) ? value : void 0;
+}
+function looksLikeExtractedStateValues(value) {
+  if (!isRecord(value) || "state" in value || "values" in value) {
+    return false;
+  }
+  return Object.values(value).every(isRecord);
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function isString(value) {
+  return typeof value === "string";
+}
+
+// src/views/controller.ts
+var DEFAULT_NAMESPACE = "agent_slack_view";
+var installedCallbackIds = /* @__PURE__ */ new WeakMap();
+function createSlackAgentViewWorkflowController({
+  namespace = DEFAULT_NAMESPACE,
+  workflows = [],
+  onError
+} = {}) {
+  const normalizedNamespace = normalizeIdentifier(namespace, "namespace");
+  const registeredWorkflows = /* @__PURE__ */ new Map();
+  const installedApps = /* @__PURE__ */ new Set();
+  function register(workflow) {
+    const workflowId = normalizeIdentifier(workflow.id, "workflow id");
+    if (!workflow.onSubmission && !workflow.onClose) {
+      throw new Error(
+        `Slack agent view workflow '${workflowId}' must define onSubmission or onClose.`
+      );
+    }
+    if (registeredWorkflows.has(workflowId)) {
+      throw new Error(`Duplicate Slack agent view workflow id: ${workflowId}`);
+    }
+    const callbackId = normalizeOptionalIdentifier(workflow.callbackId) ?? callbackIdFromWorkflowId(normalizedNamespace, workflowId);
+    if ([...registeredWorkflows.values()].some(
+      (item) => item.callbackId === callbackId
+    )) {
+      throw new Error(`Duplicate Slack view callback id: ${callbackId}`);
+    }
+    const registered = {
+      ...workflow,
+      id: workflowId,
+      callbackId
+    };
+    registeredWorkflows.set(workflowId, registered);
+    for (const app of installedApps) {
+      installWorkflow(app, registered);
+    }
+    return callbackId;
+  }
+  function callbackIdFor(workflowId) {
+    const normalizedWorkflowId = normalizeIdentifier(workflowId, "workflow id");
+    return registeredWorkflows.get(normalizedWorkflowId)?.callbackId ?? callbackIdFromWorkflowId(normalizedNamespace, normalizedWorkflowId);
+  }
+  function list() {
+    return [...registeredWorkflows.values()].map(({ id, callbackId }) => ({
+      id,
+      callbackId
+    }));
+  }
+  function install(app) {
+    installedApps.add(app);
+    for (const workflow of registeredWorkflows.values()) {
+      installWorkflow(app, workflow);
+    }
+  }
+  function installWorkflow(app, workflow) {
+    const callbackIds = callbackIdsForApp(app);
+    if (callbackIds.has(workflow.callbackId)) {
+      throw new Error(
+        `Slack view callback id '${workflow.callbackId}' is already installed on this Bolt app.`
+      );
+    }
+    callbackIds.add(workflow.callbackId);
+    registerSlackViewWorkflow({
+      boltApp: app,
+      callbackId: workflow.callbackId,
+      ...workflow.decodePrivateMetadata ? { decodePrivateMetadata: workflow.decodePrivateMetadata } : {},
+      ...workflow.onSubmission ? {
+        onSubmission: async (context) => await workflow.onSubmission(enrichContext(workflow, context))
+      } : {},
+      ...workflow.onClose ? {
+        onClose: async (context) => await workflow.onClose(enrichContext(workflow, context))
+      } : {},
+      onError: async (error, context) => {
+        const enriched = enrichContext(workflow, {
+          ...context,
+          metadata: context.metadata
+        });
+        if (workflow.onError) {
+          await workflow.onError(error, enriched);
+          return;
+        }
+        await onError?.(error, enriched);
+      }
+    });
+  }
+  for (const workflow of workflows) {
+    register(workflow);
+  }
+  return {
+    namespace: normalizedNamespace,
+    register,
+    callbackIdFor,
+    list,
+    install
+  };
+}
+function enrichContext(workflow, context) {
+  const stateValues = extractSlackAgentViewStateValues(context.view);
+  return {
+    ...context,
+    workflow: { id: workflow.id, callbackId: workflow.callbackId },
+    stateValues,
+    getStateValue: (blockId, actionId) => readSlackAgentViewStateValue(stateValues, blockId, actionId)
+  };
+}
+function callbackIdsForApp(app) {
+  let callbackIds = installedCallbackIds.get(app);
+  if (!callbackIds) {
+    callbackIds = /* @__PURE__ */ new Set();
+    installedCallbackIds.set(app, callbackIds);
+  }
+  return callbackIds;
+}
+function callbackIdFromWorkflowId(namespace, workflowId) {
+  return `${namespace}_${workflowId}`;
+}
+function normalizeOptionalIdentifier(value) {
+  const normalized = value?.trim();
+  return normalized ? normalized : void 0;
+}
+function normalizeIdentifier(value, label) {
+  const normalized = value.trim().replace(/[^A-Za-z0-9_-]+/g, "_").replace(/^_+|_+$/g, "");
+  if (!normalized) {
+    throw new Error(`Slack agent view workflow ${label} cannot be empty.`);
+  }
+  return normalized;
+}
+
+export {
+  extractSlackAgentViewStateValues,
+  readSlackAgentViewStateValue,
+  createSlackAgentViewWorkflowController
+};

package/dist/{chunk-TIQGJ52F.js → chunk-FQWFB54C.js}

@@ -2,7 +2,7 @@ import {
   UnsupportedSlackInteractiveRequestError,
   bridgeAgentEventsToSlack,
   resolveSlackEventBridgeOptions
-} from "./chunk-NOVWLAVP.js";
+} from "./chunk-TMADMHBN.js";
 
 // src/adapter/adapter.ts
 import { withinScope } from "@cuylabs/agent-core";
@@ -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;