@anuma/sdk 1.1.5 → 1.2.0

package/dist/tools/index.mjs

@@ -3246,6 +3246,7 @@ function createDropboxTools(getToken, requestAccess) {
 
 // src/tools/slack.ts
 var SLACK_PROVIDER = "slack";
+var SLACK_PENDING_APPROVAL_NOTE = "This Slack request couldn't be completed because Slack rate-limited the app. The Slack app is still pending Slack Marketplace approval, so these reads aren't available yet. Tell the user this is a temporary limitation until the app is approved; do not attempt a workaround.";
 var AUTH_ERROR_CODES = /* @__PURE__ */ new Set([
   "not_authed",
   "invalid_auth",
@@ -3269,8 +3270,10 @@ function maybeConnectorError4(status, body) {
   }
   return null;
 }
-async function callSlack(callProxy, path, query, requestBody) {
-  const { status, json } = await callProxy(path, query, requestBody);
+function isRateLimited(status, body) {
+  return status === 429 || body?.ok === false && body.error === "ratelimited";
+}
+function interpretSlackResult(path, status, json) {
   const body = json ?? null;
   if (status < 200 || status >= 300) {
     const connectorError = maybeConnectorError4(status, body);
@@ -3284,6 +3287,10 @@ async function callSlack(callProxy, path, query, requestBody) {
   }
   return body;
 }
+async function callSlack(callProxy, path, query, requestBody) {
+  const { status, json } = await callProxy(path, query, requestBody);
+  return interpretSlackResult(path, status, json);
+}
 function readString(raw) {
   return typeof raw === "string" ? raw : "";
 }
@@ -3292,6 +3299,70 @@ function clampLimit(raw, fallback, min, max) {
   const safe = typeof num === "number" && Number.isFinite(num) ? num : fallback;
   return Math.min(max, Math.max(min, safe));
 }
+function makeGetAuthUserId(callProxy) {
+  let cached;
+  return async () => {
+    if (cached === void 0) {
+      const auth = await callSlack(callProxy, "/auth.test");
+      cached = typeof auth === "string" ? null : auth.user_id ?? null;
+    }
+    return cached;
+  };
+}
+function displayNameForUser(user) {
+  return user.profile?.display_name || user.real_name || user.name || user.id;
+}
+function authorName(m, directory) {
+  const known = m.user ? directory.byId.get(m.user) : void 0;
+  return known && displayNameForUser(known) || m.username || m.user || "";
+}
+var USER_MENTION_RE = /<@([UW][A-Z0-9]+)(?:\|([^>]+))?>/g;
+var CHANNEL_MENTION_RE = /<#(C[A-Z0-9]+)(?:\|([^>]+))?>/g;
+function humanizeSlackText(text, directory) {
+  return text.replace(USER_MENTION_RE, (_match, id, handle) => {
+    const known = directory.byId.get(id);
+    return `@${known && displayNameForUser(known) || handle || id}`;
+  }).replace(
+    CHANNEL_MENTION_RE,
+    (match, _id, name) => name ? `#${name}` : match
+  );
+}
+var MAX_USERS_PAGES = 10;
+async function listAllUsers(callProxy) {
+  const all = [];
+  let cursor = "";
+  for (let page = 0; page < MAX_USERS_PAGES; page++) {
+    const query = { limit: 1e3 };
+    if (cursor) query.cursor = cursor;
+    const res = await callSlack(callProxy, "/users.list", query);
+    if (typeof res === "string") {
+      if (page === 0) return res;
+      break;
+    }
+    all.push(...res.members ?? []);
+    const next = res.response_metadata?.next_cursor;
+    if (!next) break;
+    cursor = next;
+  }
+  return all;
+}
+function makeGetUsersDirectory(callProxy) {
+  let cached;
+  return async () => {
+    if (cached === void 0) {
+      const res = await listAllUsers(callProxy);
+      const members = (typeof res === "string" ? [] : res).filter((u) => !u.deleted);
+      const byId = /* @__PURE__ */ new Map();
+      const byHandle = /* @__PURE__ */ new Map();
+      for (const user of members) {
+        byId.set(user.id, user);
+        if (user.name) byHandle.set(user.name.toLowerCase(), user);
+      }
+      cached = { members, byId, byHandle };
+    }
+    return cached;
+  };
+}
 async function getSlackMe(callProxy) {
   const auth = await callSlack(callProxy, "/auth.test");
   if (typeof auth === "string") return auth;
@@ -3314,14 +3385,10 @@ async function getSlackMe(callProxy) {
   };
 }
 async function listSlackChannels(callProxy, args) {
-  const limit = clampLimit(args.limit, 100, 1, 1e3);
-  const res = await callSlack(callProxy, "/conversations.list", {
-    limit,
-    exclude_archived: "true",
-    types: "public_channel,private_channel"
-  });
+  const limit = clampLimit(args.limit, 1e3, 1, 5e3);
+  const res = await listAllConversations(callProxy, "public_channel,private_channel");
   if (typeof res === "string") return res;
-  return (res.channels ?? []).map((c) => ({
+  return res.slice(0, limit).map((c) => ({
     id: c.id,
     name: c.name,
     is_private: c.is_private,
@@ -3330,8 +3397,150 @@ async function listSlackChannels(callProxy, args) {
     purpose: c.purpose?.value
   }));
 }
+var MAX_DM_PROBES = 50;
+async function openSlackDm(callProxy, userId) {
+  const res = await callSlack(
+    callProxy,
+    "/conversations.open",
+    void 0,
+    { users: userId }
+  );
+  if (typeof res === "string") return null;
+  return res.channel?.id ?? null;
+}
+async function dmHasMessages(callProxy, channelId) {
+  const { status, json } = await callProxy("/conversations.history", {
+    channel: channelId,
+    limit: 1
+  });
+  const body = json ?? null;
+  if (isRateLimited(status, body)) return true;
+  const res = interpretSlackResult(
+    "/conversations.history",
+    status,
+    json
+  );
+  if (typeof res === "string") return true;
+  return (res.messages ?? []).length > 0;
+}
+async function listSlackDms(callProxy, args) {
+  const res = await listAllConversations(callProxy, "im,mpim");
+  if (typeof res === "string") return res;
+  const getAuthUserId = makeGetAuthUserId(callProxy);
+  const getUsersDirectory = makeGetUsersDirectory(callProxy);
+  const dmNameCache = /* @__PURE__ */ new Map();
+  const buildListing = async (convs) => {
+    const listing = { direct_messages: [], group_dms: [] };
+    for (const conv of convs) {
+      if (conv.is_mpim) {
+        const [directory, selfId] = await Promise.all([getUsersDirectory(), getAuthUserId()]);
+        const members = groupDmMembers(conv.name, directory, selfId) ?? formatGroupDmLabel(conv.name, directory, selfId);
+        listing.group_dms.push({ id: conv.id, members });
+        continue;
+      }
+      const name = await labelForChannel(
+        callProxy,
+        conv,
+        dmNameCache,
+        getAuthUserId,
+        getUsersDirectory
+      );
+      listing.direct_messages.push({ id: conv.id, name });
+    }
+    return listing;
+  };
+  const withUserRef = (args.with_user ?? "").trim();
+  if (withUserRef) {
+    const targetId = await resolveSlackUserId(withUserRef, getAuthUserId, getUsersDirectory);
+    if (!targetId) return `Error: couldn't find a Slack user matching "${withUserRef}".`;
+    const directory = await getUsersDirectory();
+    const targetHandle = directory.byId.get(targetId)?.name?.toLowerCase();
+    const matches = res.filter((conv) => {
+      if (conv.is_mpim) {
+        return targetHandle ? parseMpdmHandles(conv.name).some((h) => h.toLowerCase() === targetHandle) : false;
+      }
+      return conv.user === targetId;
+    });
+    const targetLimit = clampLimit(args.limit, matches.length, 1, matches.length);
+    const listing = await buildListing(matches.slice(0, targetLimit));
+    if (listing.direct_messages.length === 0) {
+      const openedId = await openSlackDm(callProxy, targetId);
+      if (openedId) {
+        const surface = listing.group_dms.length === 0 || await dmHasMessages(callProxy, openedId);
+        if (surface) {
+          const counterparty = directory.byId.get(targetId);
+          listing.direct_messages.push({
+            id: openedId,
+            name: counterparty ? displayNameForUser(counterparty) : targetId
+          });
+        }
+      }
+    }
+    return listing;
+  }
+  const limit = clampLimit(args.limit, 5, 1, MAX_DM_PROBES);
+  if (res.length > MAX_DM_PROBES) return SLACK_PENDING_APPROVAL_NOTE;
+  const withTs = [];
+  const withoutTs = [];
+  for (const conv of res) {
+    const { status, json } = await callProxy("/conversations.history", {
+      channel: conv.id,
+      limit: 1
+    });
+    const body = json ?? null;
+    if (isRateLimited(status, body)) return SLACK_PENDING_APPROVAL_NOTE;
+    if (status < 200 || status >= 300 || !body || body.ok === false) {
+      withoutTs.push(conv);
+      continue;
+    }
+    const messages = body.messages ?? [];
+    if (messages.length === 0) continue;
+    withTs.push({ conv, lastTs: Number(messages[0].ts) });
+  }
+  withTs.sort((a, b) => b.lastTs - a.lastTs);
+  const ordered = [...withTs.map((x) => x.conv), ...withoutTs];
+  return buildListing(ordered.slice(0, limit));
+}
 var MAX_SEARCH_CHANNELS = 8;
 var SEARCH_HISTORY_LIMIT = 15;
+var MAX_CONVERSATIONS_PAGES = 10;
+async function listAllConversations(callProxy, types) {
+  const all = [];
+  let cursor = "";
+  for (let page = 0; page < MAX_CONVERSATIONS_PAGES; page++) {
+    const query = {
+      limit: 1e3,
+      exclude_archived: "true",
+      types
+    };
+    if (cursor) query.cursor = cursor;
+    const res = await callSlack(
+      callProxy,
+      "/conversations.list",
+      query
+    );
+    if (typeof res === "string") {
+      if (page === 0) return res;
+      break;
+    }
+    all.push(...res.channels ?? []);
+    const next = res.response_metadata?.next_cursor;
+    if (!next) break;
+    cursor = next;
+  }
+  return all;
+}
+async function resolveChannelId(callProxy, ref) {
+  const trimmed = ref.trim().replace(/^#/, "");
+  if (SLACK_CHANNEL_ID_RE.test(trimmed)) return { id: trimmed };
+  const channels = await listAllConversations(callProxy, "public_channel,private_channel");
+  if (typeof channels === "string") return channels;
+  const match = channels.find((c) => c.name?.toLowerCase() === trimmed.toLowerCase());
+  if (!match) {
+    return `Error: no Slack channel named "${ref}" in this workspace (checked the channels you're a member of).`;
+  }
+  return { id: match.id };
+}
 function interleaveChannelsAndDms(conversations) {
   const channels = conversations.filter((c) => !c.is_im && !c.is_mpim);
   const dms = conversations.filter((c) => c.is_im || c.is_mpim);
@@ -3347,8 +3556,40 @@ function messageMatchesQuery(text, terms) {
   const haystack = text.toLowerCase();
   return terms.every((term) => haystack.includes(term));
 }
-async function labelForChannel(callProxy, channel, dmNameCache, getAuthUserId) {
-  if (channel.is_mpim) return "Group DM";
+var MAX_GROUP_DM_NAMES = 5;
+var MPDM_NAME_RE = /^mpdm-(.+)-\d+$/;
+function parseMpdmHandles(mpimName) {
+  if (!mpimName) return [];
+  const match = MPDM_NAME_RE.exec(mpimName);
+  return match ? match[1].split("--") : [];
+}
+function groupDmMembers(mpimName, directory, selfId) {
+  const handles = parseMpdmHandles(mpimName);
+  if (handles.length === 0) return null;
+  const selfHandle = selfId ? directory.byId.get(selfId)?.name?.toLowerCase() : void 0;
+  const names = [];
+  for (const handle of handles) {
+    const key = handle.toLowerCase();
+    if (selfHandle && key === selfHandle) continue;
+    const member = directory.byHandle.get(key);
+    names.push(member ? displayNameForUser(member) : handle);
+  }
+  if (names.length === 0) return null;
+  const shown = names.slice(0, MAX_GROUP_DM_NAMES);
+  const extra = names.length - shown.length;
+  return `${shown.join(", ")}${extra > 0 ? `, +${extra} more` : ""}`;
+}
+function formatGroupDmLabel(mpimName, directory, selfId) {
+  if (!mpimName) return "Group DM";
+  if (parseMpdmHandles(mpimName).length === 0) return mpimName;
+  const members = groupDmMembers(mpimName, directory, selfId);
+  return members === null ? "Group DM" : `Group DM with ${members}`;
+}
+async function labelForChannel(callProxy, channel, dmNameCache, getAuthUserId, getUsersDirectory) {
+  if (channel.is_mpim) {
+    const [directory2, selfId] = await Promise.all([getUsersDirectory(), getAuthUserId()]);
+    return formatGroupDmLabel(channel.name, directory2, selfId);
+  }
   if (!channel.is_im) return channel.name ?? channel.id;
   const otherId = channel.user;
   if (!otherId) return channel.id;
@@ -3356,72 +3597,130 @@ async function labelForChannel(callProxy, channel, dmNameCache, getAuthUserId) {
   if (authUserId && otherId === authUserId) return "Direct message";
   const cached = dmNameCache.get(otherId);
   if (cached) return `DM with ${cached}`;
+  const directory = await getUsersDirectory();
+  const known = directory.byId.get(otherId);
+  if (known) {
+    const name2 = displayNameForUser(known);
+    dmNameCache.set(otherId, name2);
+    return `DM with ${name2}`;
+  }
   const info = await callSlack(callProxy, "/users.info", { user: otherId });
   if (typeof info === "string" || !info.user) return channel.id;
   const name = info.user.profile?.display_name || info.user.real_name || info.user.name || otherId;
   dmNameCache.set(otherId, name);
   return `DM with ${name}`;
 }
+var SLACK_USER_ID_RE = /^[UW][A-Z0-9]{6,}$/;
+var SLACK_CHANNEL_ID_RE = /^[CDG][A-Z0-9]{6,}$/;
+var SELF_REFS = /* @__PURE__ */ new Set(["me", "myself", "self", "i"]);
+async function resolveSlackUserId(ref, getAuthUserId, getUsersDirectory) {
+  const trimmed = ref.trim();
+  if (!trimmed) return null;
+  if (SELF_REFS.has(trimmed.toLowerCase())) return getAuthUserId();
+  if (SLACK_USER_ID_RE.test(trimmed)) return trimmed;
+  const needle = trimmed.replace(/^@/, "").toLowerCase();
+  if (!needle) return null;
+  const { members } = await getUsersDirectory();
+  const fieldsOf = (u) => [u.name, u.real_name, u.profile?.display_name].filter((f) => Boolean(f));
+  const matching = (pred) => members.filter((u) => fieldsOf(u).some((f) => pred(f.toLowerCase())));
+  const exact = matching((f) => f === needle);
+  if (exact.length === 1) return exact[0].id;
+  if (exact.length > 1) return null;
+  const partial = matching((f) => f.includes(needle));
+  return partial.length === 1 ? partial[0].id : null;
+}
 async function searchSlackMessages(callProxy, args) {
+  const query = (args.query ?? "").trim();
+  const fromUserRef = (args.from_user ?? "").trim();
+  const mentionsRef = (args.mentions ?? "").trim();
+  if (!query && !fromUserRef && !mentionsRef) {
+    return "Error: provide a query, from_user, or mentions to search Slack messages.";
+  }
   const count = clampLimit(args.count, 20, 1, 100);
-  const terms = args.query.toLowerCase().split(/\s+/).filter(Boolean);
-  const listRes = await callSlack(
-    callProxy,
-    "/conversations.list",
-    {
-      limit: 1e3,
-      exclude_archived: "true",
-      types: "public_channel,private_channel,im,mpim"
-    }
-  );
+  const terms = query.toLowerCase().split(/\s+/).filter(Boolean);
+  const getAuthUserId = makeGetAuthUserId(callProxy);
+  const getUsersDirectory = makeGetUsersDirectory(callProxy);
+  let fromId = null;
+  if (fromUserRef) {
+    fromId = await resolveSlackUserId(fromUserRef, getAuthUserId, getUsersDirectory);
+    if (!fromId)
+      return `Error: couldn't find a Slack user matching "${fromUserRef}" for from_user.`;
+  }
+  let mentionId = null;
+  if (mentionsRef) {
+    mentionId = await resolveSlackUserId(mentionsRef, getAuthUserId, getUsersDirectory);
+    if (!mentionId) {
+      return `Error: couldn't find a Slack user matching "${mentionsRef}" for mentions.`;
+    }
+  }
+  const passes = (m) => {
+    const text = m.text ?? "";
+    if (terms.length > 0 && !messageMatchesQuery(text, terms)) return false;
+    if (fromId && m.user !== fromId) return false;
+    if (mentionId && !text.includes("<@" + mentionId)) return false;
+    return true;
+  };
+  const listRes = await listAllConversations(callProxy, "public_channel,private_channel,im,mpim");
   if (typeof listRes === "string") return listRes;
-  const allChannels = listRes.channels ?? [];
+  const allChannels = listRes;
   let targets;
   if (args.channel) {
-    const found = allChannels.find((c) => c.id === args.channel || c.name === args.channel);
-    targets = [found ?? { id: args.channel, name: args.channel }];
+    const raw = args.channel.trim();
+    const bare = raw.replace(/^#/, "");
+    const found = allChannels.find(
+      (c) => c.id === raw || c.name?.toLowerCase() === bare.toLowerCase()
+    );
+    if (found) {
+      targets = [found];
+    } else if (SLACK_CHANNEL_ID_RE.test(bare)) {
+      targets = [{ id: bare, name: bare }];
+    } else {
+      return `Error: no Slack channel named "${args.channel}" in this workspace.`;
+    }
   } else {
     targets = interleaveChannelsAndDms(allChannels).slice(0, MAX_SEARCH_CHANNELS);
   }
-  let cachedAuthUserId;
-  const getAuthUserId = async () => {
-    if (cachedAuthUserId === void 0) {
-      const auth = await callSlack(callProxy, "/auth.test");
-      cachedAuthUserId = typeof auth === "string" ? null : auth.user_id ?? null;
-    }
-    return cachedAuthUserId;
-  };
   const dmNameCache = /* @__PURE__ */ new Map();
   const results = [];
   let rateLimited = false;
   for (const channel of targets) {
-    if (results.length >= count) break;
     const { status, json } = await callProxy("/conversations.history", {
       channel: channel.id,
       limit: SEARCH_HISTORY_LIMIT
     });
     const body = json ?? null;
-    if (status === 429 || body?.ok === false && body.error === "ratelimited") {
+    if (isRateLimited(status, body)) {
       rateLimited = true;
       break;
     }
     const connectorError = maybeConnectorError4(status, body);
     if (connectorError) return connectorError;
     if (status < 200 || status >= 300 || !body || body.ok === false) continue;
-    const matched = (body.messages ?? []).filter((m) => messageMatchesQuery(m.text ?? "", terms));
+    const matched = (body.messages ?? []).filter(passes);
     if (matched.length === 0) continue;
-    const label = await labelForChannel(callProxy, channel, dmNameCache, getAuthUserId);
+    const label = await labelForChannel(
+      callProxy,
+      channel,
+      dmNameCache,
+      getAuthUserId,
+      getUsersDirectory
+    );
+    const directory = await getUsersDirectory();
     for (const m of matched) {
-      if (results.length >= count) break;
-      results.push({ text: m.text, user: m.username ?? m.user, ts: m.ts, channel: label });
+      results.push({
+        text: humanizeSlackText(m.text ?? "", directory),
+        user: authorName(m, directory),
+        ts: m.ts,
+        channel: label
+      });
     }
   }
+  results.sort((a, b) => Number(b.ts) - Number(a.ts));
+  const sliced = results.slice(0, count);
   if (rateLimited) {
-    results.push({
-      note: `Slack rate-limited channel history, so this search stopped early \u2014 returning ${results.length} match(es) found so far. Try a specific channel or ask again in a minute.`
-    });
+    sliced.push({ note: SLACK_PENDING_APPROVAL_NOTE });
   }
-  return results;
+  return sliced;
 }
 async function listSlackUsers(callProxy, args) {
   const limit = clampLimit(args.limit, 100, 1, 1e3);
@@ -3437,29 +3736,46 @@ async function listSlackUsers(callProxy, args) {
 }
 async function getSlackChannelHistory(callProxy, args) {
   const limit = clampLimit(args.limit, 20, 1, 100);
-  const res = await callSlack(
-    callProxy,
+  const resolved = await resolveChannelId(callProxy, args.channel);
+  if (typeof resolved === "string") return resolved;
+  const { status, json } = await callProxy("/conversations.history", {
+    channel: resolved.id,
+    limit
+  });
+  const body = json ?? null;
+  if (isRateLimited(status, body)) return SLACK_PENDING_APPROVAL_NOTE;
+  const res = interpretSlackResult(
     "/conversations.history",
-    { channel: args.channel, limit }
+    status,
+    json
   );
   if (typeof res === "string") return res;
+  const directory = await makeGetUsersDirectory(callProxy)();
   return (res.messages ?? []).map((m) => ({
-    text: m.text,
-    user: m.username ?? m.user,
+    text: humanizeSlackText(m.text ?? "", directory),
+    user: authorName(m, directory),
     ts: m.ts
   }));
 }
 async function getSlackThreadReplies(callProxy, args) {
   const limit = clampLimit(args.limit, 20, 1, 100);
-  const res = await callSlack(
-    callProxy,
+  const { status, json } = await callProxy("/conversations.replies", {
+    channel: args.channel,
+    ts: args.ts,
+    limit
+  });
+  const body = json ?? null;
+  if (isRateLimited(status, body)) return SLACK_PENDING_APPROVAL_NOTE;
+  const res = interpretSlackResult(
     "/conversations.replies",
-    { channel: args.channel, ts: args.ts, limit }
+    status,
+    json
   );
   if (typeof res === "string") return res;
+  const directory = await makeGetUsersDirectory(callProxy)();
   return (res.messages ?? []).map((m) => ({
-    text: m.text,
-    user: m.username ?? m.user,
+    text: humanizeSlackText(m.text ?? "", directory),
+    user: authorName(m, directory),
     ts: m.ts
   }));
 }
@@ -3494,7 +3810,7 @@ function createSlackListChannelsTool(callProxy) {
         properties: {
           limit: {
             type: "number",
-            description: "Max channels to return. Between 1 and 1000 (clamped). Defaults to 100."
+            description: "Max channels to return. Between 1 and 5000 (clamped). Defaults to 1000."
           }
         },
         required: []
@@ -3508,13 +3824,13 @@ function createSlackSearchMessagesTool(callProxy) {
     type: "function",
     function: {
       name: "slack_search_messages",
-      description: "Search recent messages for text across the user's Slack channels and direct messages, or within a single channel when 'channel' is given. Matches messages containing all of the query words. Only recent history is scanned (a bounded set of conversations), so this surfaces recent mentions rather than the full archive.",
+      description: "Search recent messages across the user's Slack channels and direct messages, or within a single channel when 'channel' is given. Filter by any combination of 'query' (words the text must contain), 'from_user' (the author), and 'mentions' (who the message @-mentions) -- at least one is required. Only recent history is scanned (a bounded set of conversations), so this surfaces recent messages rather than the full archive. Use this to find messages by KEYWORD or TOPIC across conversations. Do NOT use it to read the latest/last message from a specific person or channel, or to read a specific conversation you already know: for the last message from a person, call slack_list_dms with with_user to get the DM id then slack_get_channel_history on it; for a channel, call slack_get_channel_history directly. Search fans out across many conversations and is heavily rate-limited, so a single targeted read is faster and more reliable.",
       parameters: {
         type: "object",
         properties: {
           query: {
             type: "string",
-            description: "Words to look for. A message matches when its text contains all of them (case-insensitive)."
+            description: "Optional. Words to look for; a message matches when its text contains all of them (case-insensitive). Provide this, from_user, or mentions."
           },
           count: {
             type: "number",
@@ -3523,15 +3839,52 @@ function createSlackSearchMessagesTool(callProxy) {
           channel: {
             type: "string",
             description: "Optional channel id or name to search within. Omit to search across your channels."
+          },
+          from_user: {
+            type: "string",
+            description: "Optional. The message author to filter by, as a Slack user id or a name/handle."
+          },
+          mentions: {
+            type: "string",
+            description: 'Optional. Keep only messages that @-mention this person, as a user id, a name/handle, or "me" for yourself.'
           }
         },
-        required: ["query"]
+        required: []
       }
     },
     executor: async (args) => searchSlackMessages(callProxy, {
       query: readString(args.query),
       count: args.count,
-      channel: typeof args.channel === "string" ? args.channel : void 0
+      channel: typeof args.channel === "string" ? args.channel : void 0,
+      from_user: typeof args.from_user === "string" ? args.from_user : void 0,
+      mentions: typeof args.mentions === "string" ? args.mentions : void 0
+    })
+  };
+}
+function createSlackListDmsTool(callProxy) {
+  return {
+    type: "function",
+    function: {
+      name: "slack_list_dms",
+      description: "List the user's Slack direct messages and group DMs, or find the DM with a specific person. Returns two separate lists: 'direct_messages' (1:1 conversations, each with 'name' = the other person) and 'group_dms' (group conversations, each with 'members' = the member names). When showing these to the user, present them as TWO separate bulleted lists -- a 'Direct messages' list (by the other person's name) and a 'Group DMs' list (by the member names) -- by name only, and never show the conversation ids. To show or read the conversation with one person, call this with with_user=<name or id> to get that conversation's id, then call slack_get_channel_history with that id to read the messages. For the latest message or recent messages from a specific person, the flow is: call this with with_user, take the returned id, then call slack_get_channel_history on it (use limit: 1 for just the last message). Do NOT use slack_search_messages to find a person's DM conversation or to read their latest message -- use with_user here instead. Listing all DMs (no with_user) returns the 5 MOST RECENT by default (most recent first, like the Slack sidebar, with empty conversations excluded), split across 'direct_messages' and 'group_dms'; pass a larger 'limit' to get more. The conversation id is only for passing to slack_get_channel_history to read a conversation.",
+      parameters: {
+        type: "object",
+        properties: {
+          limit: {
+            type: "number",
+            description: "Max DMs to return, default 5, up to 50."
+          },
+          with_user: {
+            type: "string",
+            description: "Optional. Return only the DM(s) with this person, as a Slack user id or a name/handle. Use this to find and read the DM with a specific person. Works even for a DM that isn't currently open -- it will open/resume the conversation to read it."
+          }
+        },
+        required: []
+      }
+    },
+    executor: async (args) => listSlackDms(callProxy, {
+      limit: args.limit,
+      with_user: typeof args.with_user === "string" ? args.with_user : void 0
     })
   };
 }
@@ -3560,7 +3913,7 @@ function createSlackGetChannelHistoryTool(callProxy) {
     type: "function",
     function: {
       name: "slack_get_channel_history",
-      description: "Fetch recent messages from a single Slack channel by id. Best-effort and heavily rate-limited (~1 request per minute for the app), so use it sparingly for a specific channel.",
+      description: "Fetch recent messages from a single Slack channel by id. Best-effort and heavily rate-limited (~1 request per minute for the app), so use it sparingly for a specific channel. This is the right tool to read the most recent messages (including just the latest one with limit: 1) from a known channel or DM id, and should be PREFERRED over slack_search_messages whenever the conversation to read is already known or identified.",
       parameters: {
         type: "object",
         properties: {
@@ -3650,6 +4003,7 @@ function createSlackTools(callProxy) {
   return {
     slack_get_me: createSlackGetMeTool(callProxy),
     slack_list_channels: createSlackListChannelsTool(callProxy),
+    slack_list_dms: createSlackListDmsTool(callProxy),
     slack_search_messages: createSlackSearchMessagesTool(callProxy),
     slack_list_users: createSlackListUsersTool(callProxy),
     slack_get_channel_history: createSlackGetChannelHistoryTool(callProxy),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@anuma/sdk",
-  "version": "1.1.5",
+  "version": "1.2.0",
   "description": "",
   "main": "./dist/index.cjs",
   "module": "./dist/index.mjs",