@cuylabs/channel-slack-agent-core 0.9.0 → 0.11.0

package/dist/chunk-GKZRDNEB.js

@@ -1,187 +0,0 @@
-import {
-  createSlackAssistantBridge
-} from "./chunk-FJP6ZFUB.js";
-import {
-  createSlackFeedbackBlock
-} from "./chunk-ELR6MQD7.js";
-import {
-  createSlackChannelAdapter
-} from "./chunk-XA7U3GRN.js";
-
-// src/app-surface.ts
-var DEFAULT_TIMEOUT_MS = 12e4;
-var DEFAULT_STREAM_ERROR_MESSAGE = "I ran into an error while preparing this answer. Please try again.";
-function installSlackAgentAppSurface(boltApp, options) {
-  const {
-    respondToMentions,
-    respondToMessages,
-    respondToChannelMessages,
-    resolveMessage,
-    feedback: feedbackOption,
-    onFeedback,
-    timeoutMs,
-    logger,
-    source,
-    prepareTurn,
-    resolveSession,
-    interactive,
-    viewWorkflows,
-    ...assistantBridgeOptions
-  } = options;
-  const feedbackConfig = feedbackOption === false ? void 0 : feedbackOption ?? (onFeedback ? { onFeedback } : {});
-  const assistantFeedback = feedbackOption === false ? false : feedbackConfig;
-  const feedbackBlock = feedbackConfig ? createSlackFeedbackBlock(feedbackConfig) : void 0;
-  const formatStreamError = assistantBridgeOptions.formatStreamError ?? (() => DEFAULT_STREAM_ERROR_MESSAGE);
-  const formatting = assistantBridgeOptions.formatChatMarkdown;
-  const channelSource = createErrorTranslatingSource(source, formatStreamError);
-  const channelFinalArgs = mergeChatStreamFinalArgs(
-    assistantBridgeOptions.chatStreamFinalArgs,
-    feedbackBlock
-  );
-  const bridge = createSlackAssistantBridge({
-    ...assistantBridgeOptions,
-    source,
-    ...assistantFeedback !== void 0 ? { feedback: assistantFeedback } : {},
-    ...timeoutMs !== void 0 ? { timeoutMs } : {},
-    ...logger ? { logger } : {},
-    ...prepareTurn ? { prepareTurn: toAssistantPrepareTurn(prepareTurn) } : {},
-    ...resolveSession ? { resolveSession: toAssistantResolveSession(resolveSession) } : {},
-    ...interactive ? { handleInteractiveRequest: interactive.handleInteractiveRequest } : {}
-  });
-  bridge.install(boltApp);
-  const channelAdapter = createSlackChannelAdapter({
-    source: channelSource,
-    sessionStrategy: assistantBridgeOptions.sessionStrategy,
-    ...resolveSession ? { resolveSession } : {},
-    ...prepareTurn ? { prepareTurn } : {},
-    ...interactive ? { handleInteractiveRequest: interactive.handleInteractiveRequest } : {},
-    streamingMode: "chat-stream",
-    showReasoning: assistantBridgeOptions.showReasoning,
-    showToolUsage: assistantBridgeOptions.showToolUsage,
-    showSubagentToolUsage: assistantBridgeOptions.showSubagentToolUsage,
-    showSubagentResultInTask: assistantBridgeOptions.showSubagentResultInTask,
-    formatToolTitle: assistantBridgeOptions.formatToolTitle,
-    formatToolUpdate: assistantBridgeOptions.formatToolUpdate,
-    formatToolDetails: assistantBridgeOptions.formatToolDetails,
-    formatToolResultOutput: assistantBridgeOptions.formatToolResultOutput,
-    formatToolError: assistantBridgeOptions.formatToolError,
-    formatReasoningUpdate: assistantBridgeOptions.formatReasoningUpdate,
-    chatStreamBufferSize: assistantBridgeOptions.chatStreamBufferSize,
-    chatStreamStartArgs: {
-      ...assistantBridgeOptions.chatStreamStartArgs ?? {},
-      task_display_mode: assistantBridgeOptions.taskDisplayMode ?? "timeline"
-    },
-    publishFinalResponseArtifact: assistantBridgeOptions.publishFinalResponseArtifact,
-    finalResponseArtifactMode: assistantBridgeOptions.finalResponseArtifactMode,
-    finalResponseArtifactStreamThreshold: assistantBridgeOptions.finalResponseArtifactStreamThreshold,
-    formatFinalResponseArtifactContinuationNotice: assistantBridgeOptions.formatFinalResponseArtifactContinuationNotice,
-    formatFinalResponseArtifactMessage: assistantBridgeOptions.formatFinalResponseArtifactMessage,
-    onFinalResponseArtifactError: assistantBridgeOptions.onFinalResponseArtifactError,
-    ...typeof assistantBridgeOptions.initialStatus === "object" && assistantBridgeOptions.initialStatus !== null ? { initialStatus: assistantBridgeOptions.initialStatus } : {},
-    ...formatting?.formatChatMarkdown !== void 0 ? { formatChatMarkdown: formatting.formatChatMarkdown } : {},
-    ...formatting?.formatMessageText ? { formatMessageText: formatting.formatMessageText } : {},
-    timeout: timeoutMs ?? DEFAULT_TIMEOUT_MS,
-    respondToMentions: respondToMentions !== false,
-    respondToMessages: respondToMessages !== false,
-    respondToChannelMessages: respondToChannelMessages === true,
-    ...resolveMessage ? { resolveMessage } : {},
-    chatStreamFinalArgs: channelFinalArgs,
-    ...logger ? { logger } : {},
-    ...logger ? {
-      onError: async (error, info) => {
-        logger.warn?.("slack channel turn failed", {
-          error: formatErrorForLog(error),
-          channelId: info.channelId,
-          userId: info.userId
-        });
-      }
-    } : {}
-  });
-  channelAdapter.mount(boltApp);
-  interactive?.install(boltApp);
-  viewWorkflows?.install(boltApp);
-  return { bridge };
-}
-function mergeChatStreamFinalArgs(base, feedbackBlock) {
-  if (!base && !feedbackBlock) {
-    return void 0;
-  }
-  const configuredBlocks = Array.isArray(base?.blocks) ? base.blocks : [];
-  const blocks = feedbackBlock ? [...configuredBlocks, feedbackBlock] : configuredBlocks;
-  return {
-    ...base ?? {},
-    ...blocks.length > 0 ? { blocks } : {}
-  };
-}
-function toAssistantPrepareTurn(prepareTurn) {
-  return (request) => prepareTurn(toAppTurnRequest(request));
-}
-function toAssistantResolveSession(resolveSession) {
-  return (request) => resolveSession(toAppTurnRequest(request));
-}
-function toAppTurnRequest(request) {
-  const user = {
-    userId: request.message.userId,
-    channelId: request.message.channelId,
-    teamId: request.message.teamId ?? request.auth.teamId,
-    threadTs: request.message.threadTs,
-    messageTs: request.message.messageTs
-  };
-  return {
-    slackActivity: request.message,
-    user,
-    sessionId: request.sessionId,
-    message: request.message.text,
-    auth: request.auth,
-    threadContext: request.threadContext,
-    assistant: request.assistant,
-    client: request.client,
-    rawArgs: request.rawArgs
-  };
-}
-function createErrorTranslatingSource(source, formatStreamError) {
-  return {
-    chat(sessionId, message, options) {
-      const events = source.chat(sessionId, message, options);
-      return translateErrors(events, formatStreamError);
-    }
-  };
-}
-async function* translateErrors(events, formatStreamError) {
-  try {
-    for await (const event of events) {
-      if (event.type === "error") {
-        yield {
-          type: "text-delta",
-          text: `
-
-${formatStreamError(toError(event.error))}`
-        };
-        yield { type: "complete" };
-        return;
-      }
-      yield event;
-    }
-  } catch (error) {
-    yield {
-      type: "text-delta",
-      text: `
-
-${formatStreamError(toError(error))}`
-    };
-    yield { type: "complete" };
-  }
-}
-function toError(value) {
-  return value instanceof Error ? value : new Error(String(value));
-}
-function formatErrorForLog(error) {
-  if (error instanceof Error) {
-    return error.stack ?? error.message;
-  }
-  return String(error);
-}
-
-export {
-  installSlackAgentAppSurface
-};

package/dist/chunk-HHXAXSG6.js

@@ -1,67 +0,0 @@
-import {
-  installSlackAgentAppSurface
-} from "./chunk-GKZRDNEB.js";
-import {
-  createSlackAssistantBridge
-} from "./chunk-FJP6ZFUB.js";
-
-// src/socket.ts
-import { createSlackSocketBoltApp } from "@cuylabs/channel-slack/transports/socket";
-async function mountSlackAssistantAgentSocket(options) {
-  const {
-    appToken: appTokenOption,
-    botToken: botTokenOption,
-    auth,
-    boltAppOptions,
-    socketModeReceiverOptions,
-    feedback: feedbackOption,
-    onFeedback,
-    start,
-    ...bridgeOptions
-  } = options;
-  const { boltApp, authMode } = await createSlackSocketBoltApp({
-    appToken: appTokenOption,
-    botToken: botTokenOption,
-    auth,
-    boltAppOptions,
-    socketModeReceiverOptions
-  });
-  const feedback = feedbackOption !== void 0 ? feedbackOption : onFeedback ? { onFeedback } : void 0;
-  const bridge = createSlackAssistantBridge({
-    ...bridgeOptions,
-    ...feedback !== void 0 ? { feedback } : {}
-  });
-  bridge.install(boltApp);
-  if (start !== false) {
-    await boltApp.start();
-  }
-  return { boltApp, bridge, authMode };
-}
-async function mountSlackAgentAppSocket(options) {
-  const {
-    appToken: appTokenOption,
-    botToken: botTokenOption,
-    auth,
-    boltAppOptions,
-    socketModeReceiverOptions,
-    start,
-    ...surfaceOptions
-  } = options;
-  const { boltApp, authMode } = await createSlackSocketBoltApp({
-    appToken: appTokenOption,
-    botToken: botTokenOption,
-    auth,
-    boltAppOptions,
-    socketModeReceiverOptions
-  });
-  const { bridge } = installSlackAgentAppSurface(boltApp, surfaceOptions);
-  if (start !== false) {
-    await boltApp.start();
-  }
-  return { boltApp, bridge, authMode };
-}
-
-export {
-  mountSlackAssistantAgentSocket,
-  mountSlackAgentAppSocket
-};

package/dist/chunk-JU5R6JZG.js

@@ -1,85 +0,0 @@
-import {
-  createSlackAssistantBridge
-} from "./chunk-FJP6ZFUB.js";
-
-// src/express-assistant.ts
-import {
-  createSlackBoltApp
-} from "@cuylabs/channel-slack/transports/http";
-async function mountSlackAssistantAgent(options) {
-  const {
-    botToken,
-    signingSecret,
-    auth,
-    path,
-    processBeforeResponse,
-    signatureVerification,
-    boltAppOptions,
-    receiverOptions,
-    port: portOption,
-    host,
-    app: providedApp,
-    feedback: feedbackOption,
-    onFeedback,
-    ...bridgeOptions
-  } = options;
-  const {
-    boltApp,
-    receiver,
-    app: expressApp,
-    authMode,
-    routePath
-  } = await createSlackBoltApp({
-    signingSecret,
-    path,
-    botToken,
-    auth,
-    app: providedApp,
-    processBeforeResponse,
-    signatureVerification,
-    boltAppOptions,
-    receiverOptions
-  });
-  const feedback = feedbackOption !== void 0 ? feedbackOption : onFeedback ? { onFeedback } : void 0;
-  const bridge = createSlackAssistantBridge({
-    ...bridgeOptions,
-    ...feedback !== void 0 ? { feedback } : {}
-  });
-  bridge.install(boltApp);
-  mountReceiverRouter(expressApp, receiver);
-  const port = portOption === void 0 ? resolvePort(process.env.PORT) : portOption;
-  let server;
-  if (!providedApp && port !== null) {
-    const onListen = () => {
-      process.stdout.write(
-        `Slack assistant listening on port ${port} at ${routePath}
-`
-      );
-    };
-    server = host ? expressApp.listen(port, host, onListen) : expressApp.listen(port, onListen);
-  }
-  return {
-    app: expressApp,
-    boltApp,
-    receiver,
-    authMode,
-    routePath,
-    bridge,
-    ...server ? { server } : {}
-  };
-}
-function resolvePort(port) {
-  if (!port) return 3e3;
-  const parsed = Number(port);
-  if (!Number.isInteger(parsed) || parsed < 0) {
-    throw new Error(`Invalid PORT value: ${port}`);
-  }
-  return parsed;
-}
-function mountReceiverRouter(app, receiver) {
-  app.use(receiver.router);
-}
-
-export {
-  mountSlackAssistantAgent
-};

package/dist/chunk-KAEZPS3U.js

@@ -1,77 +0,0 @@
-import {
-  installSlackAgentAppSurface
-} from "./chunk-GKZRDNEB.js";
-
-// src/app.ts
-import {
-  createSlackBoltApp
-} from "@cuylabs/channel-slack/transports/http";
-async function mountSlackAgentApp(options) {
-  const {
-    botToken,
-    signingSecret,
-    auth,
-    path,
-    processBeforeResponse,
-    signatureVerification,
-    boltAppOptions,
-    receiverOptions,
-    port: portOption,
-    host,
-    app: providedApp,
-    ...surfaceOptions
-  } = options;
-  const {
-    boltApp,
-    receiver,
-    app: expressApp,
-    authMode,
-    routePath
-  } = await createSlackBoltApp({
-    signingSecret,
-    path,
-    botToken,
-    auth,
-    app: providedApp,
-    processBeforeResponse,
-    signatureVerification,
-    boltAppOptions,
-    receiverOptions
-  });
-  const { bridge } = installSlackAgentAppSurface(boltApp, surfaceOptions);
-  expressApp.use(
-    receiver.router
-  );
-  const port = portOption === void 0 ? resolvePort(process.env.PORT) : portOption;
-  let server;
-  if (!providedApp && port !== null) {
-    const onListen = () => {
-      process.stdout.write(
-        `Slack agent app listening on port ${port} at ${routePath}
-`
-      );
-    };
-    server = host ? expressApp.listen(port, host, onListen) : expressApp.listen(port, onListen);
-  }
-  return {
-    app: expressApp,
-    boltApp,
-    receiver,
-    authMode,
-    routePath,
-    bridge,
-    ...server ? { server } : {}
-  };
-}
-function resolvePort(port) {
-  if (!port) return 3e3;
-  const parsed = Number(port);
-  if (!Number.isInteger(parsed) || parsed < 0) {
-    throw new Error(`Invalid PORT value: ${port}`);
-  }
-  return parsed;
-}
-
-export {
-  mountSlackAgentApp
-};

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
-};