@cuylabs/channel-slack-agent-core 0.10.0 → 0.12.0

package/dist/chunk-KQPUQJ57.js

@@ -1,482 +0,0 @@
-import {
-  UnsupportedSlackInteractiveRequestError,
-  bridgeAgentEventsToSlack,
-  resolveSlackEventBridgeOptions
-} from "./chunk-L5RAGYVJ.js";
-
-// src/adapter/adapter.ts
-import { withinScope } from "@cuylabs/agent-core";
-import {
-  extractSlackAuthContext,
-  extractSlackUserIdentity,
-  isProcessableMessage,
-  parseSlackMentionActivity,
-  parseSlackMessageActivity,
-  resolveSlackMessageFormatter,
-  runWithSlackTurnContext
-} 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") {
-    if (!options.resolveSessionId) {
-      throw new Error(
-        "SlackChannelOptions.resolveSessionId is required when sessionStrategy is 'custom'"
-      );
-    }
-    const customResolve = options.resolveSessionId;
-    return {
-      resolve(info) {
-        return customResolve(info);
-      }
-    };
-  }
-  if (strategy === "channel-id") {
-    return {
-      resolve(info) {
-        return info.channelId;
-      }
-    };
-  }
-  if (strategy === "user-per-channel") {
-    return {
-      resolve(info) {
-        return `${info.channelId}:${info.userId}`;
-      }
-    };
-  }
-  if (strategy === "user-per-thread") {
-    return {
-      resolve(info) {
-        if (info.channelType === "dm") {
-          return `${info.channelId}:${info.userId}`;
-        }
-        return `${info.channelId}:${info.threadTs ?? info.messageTs ?? info.channelId}:${info.userId}`;
-      }
-    };
-  }
-  return {
-    resolve: resolveThreadAwareSlackSessionId
-  };
-}
-
-// src/adapter/sink.ts
-function buildThreadPayload(info, respondInThread) {
-  if (!respondInThread || info.channelType === "dm") return {};
-  const threadTs = info.threadTs ?? info.messageTs;
-  return threadTs ? { thread_ts: threadTs } : {};
-}
-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;
-      const { channel, ts } = response;
-      if (!channel || !ts) {
-        throw new Error("Slack say() response did not include channel and ts.");
-      }
-      return { channel, ts };
-    },
-    async updateMessage(channel, ts, text) {
-      await client.chat.update({ channel, ts, text });
-    },
-    createChatStream({ bufferSize }) {
-      const threadTs = threadPayload.thread_ts ?? info.messageTs;
-      if (!threadTs) {
-        throw new Error(
-          "Slack chat-stream mode requires a source message timestamp."
-        );
-      }
-      const streamArgs = {
-        ...chatStreamStartArgs ?? {},
-        buffer_size: bufferSize
-      };
-      if (typeof sayStream === "function") {
-        return sayStream(streamArgs);
-      }
-      const streamer = client.chatStream({
-        channel: info.channelId,
-        thread_ts: threadTs,
-        ...info.teamId ? { recipient_team_id: info.teamId } : {},
-        recipient_user_id: info.userId,
-        ...streamArgs
-      });
-      return streamer;
-    }
-  };
-}
-function buildInteractiveResponder(say, client, info, respondInThread) {
-  const threadPayload = buildThreadPayload(info, respondInThread);
-  return {
-    async postMessage(message) {
-      const result = await say({
-        text: message.text,
-        ...message.blocks ? { blocks: message.blocks } : {},
-        ...threadPayload
-      });
-      const response = result;
-      const channel = response.channel ?? info.channelId;
-      const ts = response.ts;
-      if (!channel || !ts) {
-        throw new Error("Slack say() response did not include channel and ts.");
-      }
-      return { channel, ts };
-    },
-    async updateMessage(ref, message) {
-      await client.chat.update({
-        channel: ref.channel,
-        ts: ref.ts,
-        text: message.text,
-        ...message.blocks ? { blocks: message.blocks } : {}
-      });
-    }
-  };
-}
-
-// src/adapter/scope-attributes.ts
-function buildScopeAttributes(info, user, prep) {
-  return {
-    slackChannelId: info.channelId,
-    slackChannelType: info.channelType,
-    slackUserId: user.userId,
-    slackTeamId: user.teamId,
-    slackThreadTs: info.threadTs,
-    slackIsMention: info.isMention,
-    ...prep.scopeAttributes ?? {}
-  };
-}
-
-// src/adapter/adapter.ts
-var DEFAULT_CLASSIC_INITIAL_STATUS = {
-  status: "Thinking..."
-};
-function createSlackChannelAdapter(options) {
-  const source = resolveTurnSource(options);
-  const sessionMap = createSlackSessionMap(options);
-  const bridgeOptions = resolveSlackEventBridgeOptions(
-    {
-      showReasoning: options.showReasoning,
-      showToolUsage: options.showToolUsage,
-      showSubagentToolUsage: options.showSubagentToolUsage,
-      showSubagentResultInTask: options.showSubagentResultInTask,
-      formatToolTitle: options.formatToolTitle,
-      formatToolUpdate: options.formatToolUpdate,
-      formatToolDetails: options.formatToolDetails,
-      formatToolResultOutput: options.formatToolResultOutput,
-      formatToolError: options.formatToolError,
-      formatReasoningUpdate: options.formatReasoningUpdate,
-      interactiveMode: options.interactiveMode,
-      formatApprovalRequired: options.formatApprovalRequired,
-      formatHumanInputRequired: options.formatHumanInputRequired,
-      formatMessageText: resolveSlackMessageFormatter(options),
-      streamingMode: options.streamingMode,
-      progressiveUpdateThreshold: options.progressiveUpdateThreshold,
-      progressiveUpdateIntervalMs: options.progressiveUpdateIntervalMs,
-      chatStreamBufferSize: options.chatStreamBufferSize,
-      maxTaskUpdates: options.maxTaskUpdates,
-      maxTaskUpdateTextChars: options.maxTaskUpdateTextChars,
-      maxTaskUpdateFieldChars: options.maxTaskUpdateFieldChars,
-      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;
-  const respondInThread = options.respondInThread ?? true;
-  const respondToMentions = options.respondToMentions ?? true;
-  const respondToMessages = options.respondToMessages ?? true;
-  const respondToChannelMessages = options.respondToChannelMessages ?? false;
-  async function processTurn(slackActivity, say, client, context, utilities = {}) {
-    const rawText = slackActivity.text.trim();
-    const userText = options.resolveMessage ? await options.resolveMessage(slackActivity) : rawText;
-    if (!userText) return;
-    const initialSessionId = await sessionMap.resolve(slackActivity);
-    const userIdentity = extractSlackUserIdentity(slackActivity);
-    const auth = extractSlackAuthContext(context, slackActivity.userId);
-    const hasSayStream = typeof utilities.sayStream === "function";
-    const hasSetStatus = typeof utilities.setStatus === "function";
-    options.logger?.debug?.("slack classic turn utilities", {
-      channelId: slackActivity.channelId,
-      channelType: slackActivity.channelType,
-      isMention: slackActivity.isMention,
-      threadTs: slackActivity.threadTs,
-      messageTs: slackActivity.messageTs,
-      hasSayStream,
-      hasSetStatus
-    });
-    const baseTurnRequest = {
-      slackActivity,
-      user: userIdentity,
-      sessionId: initialSessionId,
-      message: userText,
-      auth,
-      ...utilities.setStatus ? { setStatus: utilities.setStatus } : {}
-    };
-    if (utilities.setStatus) {
-      const initialStatus = await resolveClassicInitialStatus(
-        options,
-        baseTurnRequest
-      );
-      if (initialStatus) {
-        try {
-          await utilities.setStatus(initialStatus);
-        } catch (error) {
-          options.logger?.warn?.("slack classic setStatus failed", {
-            error: formatErrorForLog(error)
-          });
-        }
-      }
-    }
-    const resolvedSessionId = await options.resolveSession?.(baseTurnRequest);
-    const sessionId = resolvedSessionId && resolvedSessionId.length > 0 ? resolvedSessionId : initialSessionId;
-    const turnRequest = {
-      ...baseTurnRequest,
-      sessionId
-    };
-    const preparedTurn = await resolveTurnPreparation(
-      options,
-      turnRequest,
-      userIdentity
-    );
-    const finalSessionId = preparedTurn.sessionId && preparedTurn.sessionId.length > 0 ? preparedTurn.sessionId : sessionId;
-    const finalUserText = preparedTurn.message ?? userText;
-    const sink = buildResponseSink(
-      say,
-      client,
-      slackActivity,
-      respondInThread,
-      options.chatStreamStartArgs,
-      utilities.sayStream
-    );
-    const abortController = new AbortController();
-    const chatOptions = {
-      abort: abortController.signal
-    };
-    if (preparedTurn.system) {
-      chatOptions.system = preparedTurn.system;
-    }
-    const timeoutId = timeout > 0 ? setTimeout(() => abortController.abort(), timeout) : void 0;
-    try {
-      const scopeAttributes = buildScopeAttributes(
-        slackActivity,
-        userIdentity,
-        preparedTurn
-      );
-      await runWithSlackTurnContext(
-        {
-          ...turnRequest,
-          sessionId: finalSessionId,
-          message: finalUserText,
-          ...utilities.setStatus ? { setStatus: utilities.setStatus } : {},
-          ...preparedTurn.context ? { context: preparedTurn.context } : {}
-        },
-        () => withinScope(
-          {
-            kind: "activity",
-            name: preparedTurn.scopeName?.trim() || "slack-activity",
-            sessionId: finalSessionId,
-            attributes: scopeAttributes
-          },
-          async () => {
-            const events = source.chat(
-              finalSessionId,
-              finalUserText,
-              chatOptions
-            );
-            const baseTurnBridgeOptions = options.handleInteractiveRequest ? {
-              ...bridgeOptions,
-              handleInteractiveRequest: (interactive) => options.handleInteractiveRequest({
-                ...interactive,
-                slackActivity,
-                user: userIdentity,
-                sessionId: finalSessionId,
-                message: finalUserText,
-                responder: buildInteractiveResponder(
-                  say,
-                  client,
-                  slackActivity,
-                  respondInThread
-                )
-              })
-            } : bridgeOptions;
-            const turnBridgeOptions = withClassicStatusUpdates(
-              baseTurnBridgeOptions,
-              utilities.setStatus
-            );
-            await bridgeAgentEventsToSlack(events, sink, turnBridgeOptions);
-          }
-        )
-      );
-    } catch (error) {
-      const errorInstance = error instanceof Error ? error : new Error(String(error));
-      if (!(errorInstance instanceof UnsupportedSlackInteractiveRequestError)) {
-        await say({
-          text: `I encountered an error while processing your request: ${errorInstance.message}`,
-          ...buildThreadPayload(slackActivity, respondInThread)
-        }).catch(() => void 0);
-      }
-      if (options.onError) {
-        await options.onError(errorInstance, slackActivity);
-      }
-    } finally {
-      if (timeoutId) {
-        clearTimeout(timeoutId);
-      }
-      if (utilities.setStatus) {
-        await utilities.setStatus({ status: "" }).catch(
-          (error) => options.logger?.warn?.("slack classic clear status failed", {
-            error: formatErrorForLog(error)
-          })
-        );
-      }
-    }
-  }
-  function mount(app) {
-    if (respondToMessages) {
-      app.message(
-        async ({
-          message,
-          say,
-          client,
-          context,
-          sayStream,
-          setStatus
-        }) => {
-          const raw = message;
-          if (!isProcessableMessage(
-            raw
-          )) {
-            return;
-          }
-          const info = parseSlackMessageActivity(
-            raw
-          );
-          if (info.channelType !== "dm" && !respondToChannelMessages) {
-            return;
-          }
-          if (!info.text) return;
-          await processTurn(info, say, client, context, {
-            ...typeof sayStream === "function" ? { sayStream } : {},
-            ...typeof setStatus === "function" ? { setStatus } : {}
-          });
-        }
-      );
-    }
-    if (respondToMentions) {
-      app.event(
-        "app_mention",
-        async ({
-          event,
-          say,
-          client,
-          context,
-          sayStream,
-          setStatus
-        }) => {
-          const info = parseSlackMentionActivity(
-            event
-          );
-          if (!info.text) return;
-          await processTurn(info, say, client, context, {
-            ...typeof sayStream === "function" ? { sayStream } : {},
-            ...typeof setStatus === "function" ? { setStatus } : {}
-          });
-        }
-      );
-    }
-    if (options.welcomeMessage != null) {
-      app.event("member_joined_channel", async ({ event, client }) => {
-        const channelId = event.channel;
-        const userId = event.user;
-        const botInfo = await client.auth.test().catch(() => void 0);
-        if (botInfo?.user_id === userId) return;
-        await client.chat.postMessage({
-          channel: userId,
-          // DM the new member
-          text: options.welcomeMessage
-        }).catch(() => void 0);
-        await client.chat.postMessage({
-          channel: channelId,
-          text: options.welcomeMessage
-        }).catch(() => void 0);
-      });
-    }
-  }
-  return {
-    mount,
-    getSessionId: (info) => sessionMap.resolve(info)
-  };
-}
-function formatClassicSlackStatusUpdate(status) {
-  return { status };
-}
-async function resolveClassicInitialStatus(options, request) {
-  if (options.initialStatus === void 0) {
-    return DEFAULT_CLASSIC_INITIAL_STATUS;
-  }
-  if (typeof options.initialStatus === "function") {
-    return await options.initialStatus(request) ?? void 0;
-  }
-  return options.initialStatus;
-}
-function withClassicStatusUpdates(options, setStatus) {
-  if (!setStatus) {
-    return options;
-  }
-  return {
-    ...options,
-    onStatusChange: async (label, event) => {
-      await options.onStatusChange?.(label, event);
-      await setStatus(formatClassicSlackStatusUpdate(label));
-    }
-  };
-}
-function resolveTurnSource(options) {
-  const hasAgent = options.agent !== void 0;
-  const hasSource = options.source !== void 0;
-  if (hasAgent === hasSource) {
-    throw new Error(
-      "Provide exactly one of SlackChannelOptions.agent or SlackChannelOptions.source."
-    );
-  }
-  if (options.source) return options.source;
-  if (options.agent) return options.agent;
-  throw new Error(
-    "Provide exactly one of SlackChannelOptions.agent or SlackChannelOptions.source."
-  );
-}
-async function resolveTurnPreparation(options, request, user) {
-  if (options.prepareTurn) {
-    return await options.prepareTurn(request) ?? {};
-  }
-  if (options.resolveUserContext) {
-    const ctx = await options.resolveUserContext(user);
-    return ctx ?? {};
-  }
-  return {};
-}
-function formatErrorForLog(error) {
-  if (error instanceof Error) {
-    return error.stack ?? error.message;
-  }
-  return String(error);
-}
-
-export {
-  createSlackSessionMap,
-  createSlackChannelAdapter
-};

package/dist/chunk-NNCVHQC4.js

@@ -1,94 +0,0 @@
-// 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
-};