@vellumai/assistant 0.4.11 → 0.4.13

package/src/config/bundled-skills/slack/TOOLS.json

@@ -0,0 +1,167 @@
+{
+  "version": 1,
+  "tools": [
+    {
+      "name": "slack_scan_digest",
+      "description": "Scan multiple Slack channels and return a digest of recent activity including top threads, participants, and privacy status.",
+      "category": "slack",
+      "risk": "low",
+      "input_schema": {
+        "type": "object",
+        "properties": {
+          "channel_ids": {
+            "type": "array",
+            "items": { "type": "string" },
+            "description": "Specific channel IDs to scan. If omitted, scans preferred or top active channels."
+          },
+          "hours_back": {
+            "type": "number",
+            "description": "How many hours of history to scan (default 24)"
+          },
+          "include_threads": {
+            "type": "boolean",
+            "description": "Whether to fetch thread replies for top threads (default true)"
+          },
+          "max_channels": {
+            "type": "number",
+            "description": "Maximum number of channels to scan (default 20)"
+          }
+        }
+      },
+      "executor": "tools/slack-scan-digest.ts",
+      "execution_target": "host"
+    },
+    {
+      "name": "slack_channel_details",
+      "description": "Get detailed information about a single Slack channel including name, topic, purpose, privacy status, and member count.",
+      "category": "slack",
+      "risk": "low",
+      "input_schema": {
+        "type": "object",
+        "properties": {
+          "channel_id": {
+            "type": "string",
+            "description": "The Slack channel ID to get details for"
+          }
+        },
+        "required": ["channel_id"]
+      },
+      "executor": "tools/slack-channel-details.ts",
+      "execution_target": "host"
+    },
+    {
+      "name": "slack_configure_channels",
+      "description": "Manage preferred Slack channels for scanning. List, add, remove, or set the preferred channel list.",
+      "category": "slack",
+      "risk": "low",
+      "input_schema": {
+        "type": "object",
+        "properties": {
+          "action": {
+            "type": "string",
+            "enum": ["list", "add", "remove", "set"],
+            "description": "Action to perform on the preferred channels list"
+          },
+          "channel_ids": {
+            "type": "array",
+            "items": { "type": "string" },
+            "description": "Channel IDs to add, remove, or set (not needed for 'list')"
+          }
+        },
+        "required": ["action"]
+      },
+      "executor": "tools/slack-configure-channels.ts",
+      "execution_target": "host"
+    },
+    {
+      "name": "slack_add_reaction",
+      "description": "Add an emoji reaction to a Slack message. Include a confidence score (0-1).",
+      "category": "slack",
+      "risk": "medium",
+      "input_schema": {
+        "type": "object",
+        "properties": {
+          "channel": {
+            "type": "string",
+            "description": "Slack channel ID"
+          },
+          "timestamp": {
+            "type": "string",
+            "description": "Message timestamp (ts)"
+          },
+          "emoji": {
+            "type": "string",
+            "description": "Emoji name without colons (e.g. \"thumbsup\")"
+          },
+          "confidence": {
+            "type": "number",
+            "description": "Confidence score (0-1) for this action"
+          }
+        },
+        "required": [
+          "channel",
+          "timestamp",
+          "emoji",
+          "confidence"
+        ]
+      },
+      "executor": "tools/slack-add-reaction.ts",
+      "execution_target": "host"
+    },
+    {
+      "name": "slack_delete_message",
+      "description": "Delete a Slack message posted by the bot. Include a confidence score (0-1).",
+      "category": "slack",
+      "risk": "high",
+      "input_schema": {
+        "type": "object",
+        "properties": {
+          "channel": {
+            "type": "string",
+            "description": "Slack channel ID"
+          },
+          "timestamp": {
+            "type": "string",
+            "description": "Message timestamp (ts) to delete"
+          },
+          "confidence": {
+            "type": "number",
+            "description": "Confidence score (0-1) for this action"
+          }
+        },
+        "required": [
+          "channel",
+          "timestamp",
+          "confidence"
+        ]
+      },
+      "executor": "tools/slack-delete-message.ts",
+      "execution_target": "host"
+    },
+    {
+      "name": "slack_leave_channel",
+      "description": "Leave a Slack channel. Include a confidence score (0-1).",
+      "category": "slack",
+      "risk": "medium",
+      "input_schema": {
+        "type": "object",
+        "properties": {
+          "channel": {
+            "type": "string",
+            "description": "Slack channel ID to leave"
+          },
+          "confidence": {
+            "type": "number",
+            "description": "Confidence score (0-1) for this action"
+          }
+        },
+        "required": [
+          "channel",
+          "confidence"
+        ]
+      },
+      "executor": "tools/slack-leave-channel.ts",
+      "execution_target": "host"
+    }
+  ]
+}

package/src/config/bundled-skills/slack/tools/shared.ts

@@ -0,0 +1,23 @@
+/**
+ * Shared utilities for slack skill tools.
+ */
+
+import { getMessagingProvider } from '../../../../messaging/registry.js';
+import { withValidToken } from '../../../../security/token-manager.js';
+import type { ToolExecutionResult } from '../../../../tools/types.js';
+
+export function ok(content: string): ToolExecutionResult {
+  return { content, isError: false };
+}
+
+export function err(message: string): ToolExecutionResult {
+  return { content: message, isError: true };
+}
+
+/**
+ * Execute a callback with a valid Slack OAuth token.
+ */
+export async function withSlackToken<T>(fn: (token: string) => Promise<T>): Promise<T> {
+  const provider = getMessagingProvider('slack');
+  return withValidToken(provider.credentialService, fn);
+}

package/src/config/bundled-skills/{messaging → slack}/tools/slack-add-reaction.ts

@@ -1,8 +1,6 @@
 import { addReaction } from '../../../../messaging/providers/slack/client.js';
-import { getMessagingProvider } from '../../../../messaging/registry.js';
-import { withValidToken } from '../../../../security/token-manager.js';
 import type { ToolContext, ToolExecutionResult } from '../../../../tools/types.js';
-import { err,ok } from './shared.js';
+import { err, ok, withSlackToken } from './shared.js';
 
 export async function run(input: Record<string, unknown>, _context: ToolContext): Promise<ToolExecutionResult> {
   const channel = input.channel as string;
@@ -14,8 +12,7 @@ export async function run(input: Record<string, unknown>, _context: ToolContext)
   }
 
   try {
-    const provider = getMessagingProvider('slack');
-    return withValidToken(provider.credentialService, async (token) => {
+    return withSlackToken(async (token) => {
       await addReaction(token, channel, timestamp, emoji);
       return ok(`Added :${emoji}: reaction.`);
     });

package/src/config/bundled-skills/slack/tools/slack-channel-details.ts

@@ -0,0 +1,33 @@
+import * as slack from '../../../../messaging/providers/slack/client.js';
+import type { ToolContext, ToolExecutionResult } from '../../../../tools/types.js';
+import { err, ok, withSlackToken } from './shared.js';
+
+export async function run(input: Record<string, unknown>, _context: ToolContext): Promise<ToolExecutionResult> {
+  const channelId = input.channel_id as string;
+
+  if (!channelId) {
+    return err('channel_id is required.');
+  }
+
+  try {
+    return withSlackToken(async (token) => {
+      const resp = await slack.conversationInfo(token, channelId);
+      const conv = resp.channel;
+
+      const result = {
+        channelId: conv.id,
+        name: conv.name ?? conv.id,
+        topic: conv.topic?.value || null,
+        purpose: conv.purpose?.value || null,
+        isPrivate: conv.is_private ?? conv.is_group ?? false,
+        isArchived: conv.is_archived ?? false,
+        memberCount: conv.num_members ?? null,
+        latestActivityTs: conv.latest?.ts ?? null,
+      };
+
+      return ok(JSON.stringify(result, null, 2));
+    });
+  } catch (e) {
+    return err(e instanceof Error ? e.message : String(e));
+  }
+}

package/src/config/bundled-skills/slack/tools/slack-configure-channels.ts

@@ -0,0 +1,75 @@
+import { getConfig, saveConfig } from '../../../../config/loader.js';
+import type { ToolContext, ToolExecutionResult } from '../../../../tools/types.js';
+import { err, ok } from './shared.js';
+
+function getPreferredChannels(): string[] {
+  const config = getConfig();
+  const channels = config.skills?.entries?.slack?.config?.preferredChannels;
+  return Array.isArray(channels) ? channels as string[] : [];
+}
+
+function setPreferredChannels(channels: string[]): void {
+  const config = getConfig();
+  if (!config.skills) config.skills = {} as typeof config.skills;
+  if (!config.skills.entries) config.skills.entries = {};
+  if (!config.skills.entries.slack) config.skills.entries.slack = { enabled: true };
+  if (!config.skills.entries.slack.config) config.skills.entries.slack.config = {};
+  config.skills.entries.slack.config.preferredChannels = channels;
+  saveConfig(config);
+}
+
+export async function run(input: Record<string, unknown>, _context: ToolContext): Promise<ToolExecutionResult> {
+  const action = input.action as string;
+  const channelIds = input.channel_ids as string[] | undefined;
+
+  if (!action) {
+    return err('action is required (list, add, remove, or set).');
+  }
+
+  try {
+    switch (action) {
+      case 'list': {
+        const channels = getPreferredChannels();
+        if (channels.length === 0) {
+          return ok('No preferred channels configured. Use action "set" or "add" to configure channels.');
+        }
+        return ok(JSON.stringify({ preferredChannels: channels }, null, 2));
+      }
+
+      case 'add': {
+        if (!channelIds?.length) {
+          return err('channel_ids required for "add" action.');
+        }
+        const current = getPreferredChannels();
+        const merged = [...new Set([...current, ...channelIds])];
+        setPreferredChannels(merged);
+        return ok(JSON.stringify({ preferredChannels: merged, added: channelIds.filter((id) => !current.includes(id)) }, null, 2));
+      }
+
+      case 'remove': {
+        if (!channelIds?.length) {
+          return err('channel_ids required for "remove" action.');
+        }
+        const current = getPreferredChannels();
+        const removeSet = new Set(channelIds);
+        const remaining = current.filter((id) => !removeSet.has(id));
+        setPreferredChannels(remaining);
+        return ok(JSON.stringify({ preferredChannels: remaining, removed: channelIds.filter((id) => current.includes(id)) }, null, 2));
+      }
+
+      case 'set': {
+        if (!channelIds) {
+          return err('channel_ids required for "set" action.');
+        }
+        const unique = [...new Set(channelIds)];
+        setPreferredChannels(unique);
+        return ok(JSON.stringify({ preferredChannels: unique }, null, 2));
+      }
+
+      default:
+        return err(`Unknown action "${action}". Use list, add, remove, or set.`);
+    }
+  } catch (e) {
+    return err(e instanceof Error ? e.message : String(e));
+  }
+}

package/src/config/bundled-skills/{messaging → slack}/tools/slack-delete-message.ts

@@ -1,8 +1,6 @@
 import { deleteMessage } from '../../../../messaging/providers/slack/client.js';
-import { getMessagingProvider } from '../../../../messaging/registry.js';
-import { withValidToken } from '../../../../security/token-manager.js';
 import type { ToolContext, ToolExecutionResult } from '../../../../tools/types.js';
-import { err, ok } from './shared.js';
+import { err, ok, withSlackToken } from './shared.js';
 
 export async function run(input: Record<string, unknown>, _context: ToolContext): Promise<ToolExecutionResult> {
   const channel = input.channel as string;
@@ -13,8 +11,7 @@ export async function run(input: Record<string, unknown>, _context: ToolContext)
   }
 
   try {
-    const provider = getMessagingProvider('slack');
-    return withValidToken(provider.credentialService, async (token) => {
+    return withSlackToken(async (token) => {
       await deleteMessage(token, channel, timestamp);
       return ok(`Message deleted.`);
     });

package/src/config/bundled-skills/{messaging → slack}/tools/slack-leave-channel.ts

@@ -1,8 +1,6 @@
 import { leaveConversation } from '../../../../messaging/providers/slack/client.js';
-import { getMessagingProvider } from '../../../../messaging/registry.js';
-import { withValidToken } from '../../../../security/token-manager.js';
 import type { ToolContext, ToolExecutionResult } from '../../../../tools/types.js';
-import { err,ok } from './shared.js';
+import { err, ok, withSlackToken } from './shared.js';
 
 export async function run(input: Record<string, unknown>, _context: ToolContext): Promise<ToolExecutionResult> {
   const channel = input.channel as string;
@@ -12,8 +10,7 @@ export async function run(input: Record<string, unknown>, _context: ToolContext)
   }
 
   try {
-    const provider = getMessagingProvider('slack');
-    return withValidToken(provider.credentialService, async (token) => {
+    return withSlackToken(async (token) => {
       await leaveConversation(token, channel);
       return ok('Left channel.');
     });

package/src/config/bundled-skills/slack/tools/slack-scan-digest.ts

@@ -0,0 +1,193 @@
+import * as slack from '../../../../messaging/providers/slack/client.js';
+import type { SlackConversation } from '../../../../messaging/providers/slack/types.js';
+import { getConfig } from '../../../../config/loader.js';
+import type { ToolContext, ToolExecutionResult } from '../../../../tools/types.js';
+import { err, ok, withSlackToken } from './shared.js';
+
+interface ThreadSummary {
+  threadTs: string;
+  previewText: string;
+  replyCount: number;
+  participants: string[];
+}
+
+interface ChannelDigest {
+  channelId: string;
+  channelName: string;
+  isPrivate: boolean;
+  messageCount: number;
+  topThreads: ThreadSummary[];
+  keyParticipants: string[];
+  error?: string;
+}
+
+const userNameCache = new Map<string, string>();
+
+async function resolveUserName(token: string, userId: string): Promise<string> {
+  if (!userId) return 'unknown';
+  const cached = userNameCache.get(userId);
+  if (cached) return cached;
+
+  try {
+    const resp = await slack.userInfo(token, userId);
+    const name = resp.user.profile?.display_name
+      || resp.user.profile?.real_name
+      || resp.user.real_name
+      || resp.user.name;
+    userNameCache.set(userId, name);
+    return name;
+  } catch {
+    return userId;
+  }
+}
+
+async function scanChannel(
+  token: string,
+  conv: SlackConversation,
+  oldestTs: string,
+  includeThreads: boolean,
+): Promise<ChannelDigest> {
+  const channelId = conv.id;
+  const channelName = conv.name ?? channelId;
+  const isPrivate = conv.is_private ?? conv.is_group ?? false;
+
+  try {
+    const history = await slack.conversationHistory(token, channelId, 100, undefined, oldestTs);
+    const messages = history.messages;
+
+    const participantIds = new Set<string>();
+    for (const msg of messages) {
+      if (msg.user) participantIds.add(msg.user);
+    }
+
+    const keyParticipants: string[] = [];
+    for (const uid of participantIds) {
+      keyParticipants.push(await resolveUserName(token, uid));
+    }
+
+    const threadMessages = messages
+      .filter((m) => (m.reply_count ?? 0) > 0)
+      .sort((a, b) => (b.reply_count ?? 0) - (a.reply_count ?? 0))
+      .slice(0, 3);
+
+    const topThreads: ThreadSummary[] = [];
+    for (const msg of threadMessages) {
+      let participants: string[] = [];
+
+      if (includeThreads) {
+        try {
+          const replies = await slack.conversationReplies(token, channelId, msg.ts, 10);
+          const threadParticipantIds = new Set<string>();
+          for (const reply of replies.messages) {
+            if (reply.user) threadParticipantIds.add(reply.user);
+          }
+          for (const uid of threadParticipantIds) {
+            participants.push(await resolveUserName(token, uid));
+          }
+        } catch {
+          participants = [await resolveUserName(token, msg.user ?? '')];
+        }
+      }
+
+      topThreads.push({
+        threadTs: msg.ts,
+        previewText: truncate(msg.text, 150),
+        replyCount: msg.reply_count ?? 0,
+        participants,
+      });
+    }
+
+    return {
+      channelId,
+      channelName,
+      isPrivate,
+      messageCount: messages.length,
+      topThreads,
+      keyParticipants,
+    };
+  } catch (e) {
+    return {
+      channelId,
+      channelName,
+      isPrivate,
+      messageCount: 0,
+      topThreads: [],
+      keyParticipants: [],
+      error: e instanceof Error ? e.message : String(e),
+    };
+  }
+}
+
+function truncate(text: string, maxLen: number): string {
+  if (text.length <= maxLen) return text;
+  return text.slice(0, maxLen - 3) + '...';
+}
+
+export async function run(input: Record<string, unknown>, _context: ToolContext): Promise<ToolExecutionResult> {
+  const channelIds = input.channel_ids as string[] | undefined;
+  const hoursBack = (input.hours_back as number) ?? 24;
+  const includeThreads = (input.include_threads as boolean) ?? true;
+  const maxChannels = (input.max_channels as number) ?? 20;
+
+  try {
+    return withSlackToken(async (token) => {
+      const oldestTs = String((Date.now() - hoursBack * 60 * 60 * 1000) / 1000);
+
+      let channelsToScan: SlackConversation[];
+
+      if (channelIds?.length) {
+        const results = await Promise.allSettled(
+          channelIds.map((id) => slack.conversationInfo(token, id)),
+        );
+        channelsToScan = results
+          .filter((r): r is PromiseFulfilledResult<Awaited<ReturnType<typeof slack.conversationInfo>>> => r.status === 'fulfilled')
+          .map((r) => r.value.channel);
+      } else {
+        const config = getConfig();
+        const preferredIds = config.skills?.entries?.slack?.config?.preferredChannels as string[] | undefined;
+
+        if (preferredIds?.length) {
+          const results = await Promise.allSettled(
+            preferredIds.map((id) => slack.conversationInfo(token, id)),
+          );
+          channelsToScan = results
+            .filter((r): r is PromiseFulfilledResult<Awaited<ReturnType<typeof slack.conversationInfo>>> => r.status === 'fulfilled')
+            .map((r) => r.value.channel);
+        } else {
+          const resp = await slack.listConversations(token, 'public_channel,private_channel', true, 200);
+          channelsToScan = resp.channels
+            .filter((c) => c.is_member)
+            .sort((a, b) => {
+              const aTs = a.latest?.ts ? parseFloat(a.latest.ts) : 0;
+              const bTs = b.latest?.ts ? parseFloat(b.latest.ts) : 0;
+              return bTs - aTs;
+            })
+            .slice(0, maxChannels);
+        }
+      }
+
+      const scanResults = await Promise.allSettled(
+        channelsToScan.map((conv) => scanChannel(token, conv, oldestTs, includeThreads)),
+      );
+
+      const digests: ChannelDigest[] = scanResults
+        .filter((r): r is PromiseFulfilledResult<ChannelDigest> => r.status === 'fulfilled')
+        .map((r) => r.value)
+        .filter((d) => d.messageCount > 0 || d.error);
+
+      const skippedCount = scanResults.filter((r) => r.status === 'rejected').length;
+
+      const result = {
+        scannedChannels: digests.length,
+        totalChannelsAttempted: channelsToScan.length,
+        skippedDueToErrors: skippedCount,
+        hoursBack,
+        channels: digests,
+      };
+
+      return ok(JSON.stringify(result, null, 2));
+    });
+  } catch (e) {
+    return err(e instanceof Error ? e.message : String(e));
+  }
+}