@todoist/comms-mcp 0.0.0-stage → 11.0.0

package/dist/tools/fetch-inbox.js

@@ -0,0 +1,227 @@
+import { ARCHIVE_FILTER_VALUES, getFullCommsURL } from '@doist/comms-sdk';
+import { z } from 'zod';
+import { limitedAll } from '../utils/concurrency.js';
+import { degradeAllWithLog, resolveUsersWithLog } from '../utils/degrade.js';
+import { FetchInboxOutputSchema } from '../utils/output-schemas.js';
+import { ToolNames } from '../utils/tool-names.js';
+const ArgsSchema = {
+    workspaceId: z.number().describe('The workspace ID to fetch inbox for.'),
+    sinceDate: z
+        .string()
+        .optional()
+        .describe('Optional date to get items since (YYYY-MM-DD format).'),
+    untilDate: z
+        .string()
+        .optional()
+        .describe('Optional date to get items until (YYYY-MM-DD format).'),
+    limit: z
+        .number()
+        .int()
+        .min(1)
+        .max(100)
+        .optional()
+        .default(50)
+        .describe('Maximum number of items to return.'),
+    onlyUnread: z.boolean().optional().default(false).describe('Only return unread items.'),
+    archiveFilter: z
+        .enum(ARCHIVE_FILTER_VALUES)
+        .optional()
+        .default('active')
+        .describe('Filter inbox threads by archive status. ' +
+        '"active" (default) shows only current threads, ' +
+        '"archived" shows only done/archived threads, ' +
+        '"all" shows both active and done threads.'),
+};
+// Names the conversation by its participants, falling back to the ID when none
+// of them could be resolved.
+function describeConversation(participantNames, conversationId) {
+    return participantNames.length > 0
+        ? `DM with ${participantNames.join(', ')}`
+        : `Conversation ${conversationId}`;
+}
+/**
+ * Helper function to load conversation details with participant information
+ */
+async function loadConversationDetails(client, conversationIds) {
+    if (conversationIds.length === 0) {
+        return [];
+    }
+    // Load all conversation metadata in parallel
+    const conversations = await Promise.all(conversationIds.map((id) => client.conversations.getConversation(id)));
+    // Collect all unique user IDs from all conversations
+    const allUserIds = new Set();
+    for (const conv of conversations) {
+        for (const userId of conv.userIds) {
+            allUserIds.add(userId);
+        }
+    }
+    const workspaceId = conversations[0]?.workspaceId;
+    if (!workspaceId) {
+        return conversations.map((conversation) => ({ conversation, participants: [] }));
+    }
+    // A participant that cannot be resolved is dropped rather than failing the
+    // whole inbox: one unreachable user should not cost the caller every thread.
+    // Logged so a dropped name stays distinguishable from a backend outage.
+    const users = await resolveUsersWithLog(client, ToolNames.FETCH_INBOX, 'failed to resolve conversation participant', workspaceId, Array.from(allUserIds));
+    // Map conversations to include their participants
+    return conversations.map((conversation) => ({
+        conversation,
+        participants: conversation.userIds
+            .map((id) => users.get(id))
+            .filter((user) => !!user),
+    }));
+}
+const fetchInbox = {
+    name: ToolNames.FETCH_INBOX,
+    description: 'Fetch inbox view with threads, conversations, unread counts, and unread IDs. Provides a complete picture of the inbox state. Use archiveFilter "all" to include threads marked as done alongside active threads.',
+    parameters: ArgsSchema,
+    outputSchema: FetchInboxOutputSchema.shape,
+    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true },
+    async execute(args, client) {
+        const { workspaceId, sinceDate, untilDate, limit, onlyUnread } = args;
+        const archiveFilter = args.archiveFilter ?? 'active';
+        // Call all 4 endpoints in parallel for complete inbox picture
+        const [inboxThreads, unreadCount, unreadThreadsData, unreadConversationsData] = await Promise.all([
+            client.inbox.getInbox({
+                workspaceId,
+                newerThan: sinceDate ? new Date(sinceDate) : undefined,
+                olderThan: untilDate ? new Date(untilDate) : undefined,
+                limit,
+                archiveFilter,
+            }),
+            client.inbox.getCount(workspaceId),
+            client.threads.getUnread(workspaceId),
+            client.conversations.getUnread(workspaceId),
+        ]);
+        // Filter by unread if requested
+        let threads = inboxThreads.map((thread) => ({
+            ...thread,
+            isUnread: unreadThreadsData.data.some((ut) => ut.threadId === thread.id),
+            isArchived: thread.isArchived,
+        }));
+        const unreadThreads = threads.filter((t) => t.isUnread);
+        const unreadThreadsOriginal = inboxThreads.filter((thread) => unreadThreadsData.data.some((ut) => ut.threadId === thread.id));
+        if (onlyUnread) {
+            threads = unreadThreads;
+        }
+        // Load unread conversations if any exist
+        const unreadConversationsOriginal = unreadConversationsData.data;
+        const unreadConversationIds = unreadConversationsOriginal.map((uc) => uc.conversationId);
+        let conversationsWithDetails = [];
+        // Only load and display conversations if there are unread ones
+        if (unreadConversationIds.length > 0) {
+            const conversationDetails = await loadConversationDetails(client, unreadConversationIds);
+            conversationsWithDetails = conversationDetails.map((detail) => ({
+                ...detail,
+                isUnread: true,
+            }));
+        }
+        // Build text content
+        const lines = [
+            `# Inbox for Workspace ${workspaceId}`,
+            '',
+            `**Total Threads:** ${threads.length}`,
+            `**Unread Threads:** ${unreadThreads.length}`,
+        ];
+        // Only add conversation counts if there are unread conversations
+        if (conversationsWithDetails.length > 0) {
+            lines.push(`**Total Conversations:** ${conversationsWithDetails.length}`);
+            lines.push(`**Unread Conversations:** ${conversationsWithDetails.length}`);
+        }
+        lines.push('');
+        lines.push(`## Threads (${threads.length})`);
+        lines.push('');
+        // Dedupe channel IDs so we hit `channels.getChannel` once per channel
+        // even when the inbox page is dominated by threads from the same channel.
+        // `limitedAll` caps the burst on a large inbox page.
+        const uniqueChannelIds = Array.from(new Set(threads.map((t) => t.channelId)));
+        const channelResponses = await degradeAllWithLog(ToolNames.FETCH_INBOX, 'failed to resolve channel', uniqueChannelIds, (channelId) => client.channels.getChannel(channelId), { runner: limitedAll });
+        const channelInfo = channelResponses.reduce((acc, channel) => {
+            if (channel)
+                acc[channel.id] = channel;
+            return acc;
+        }, {});
+        if (threads.length === 0) {
+            lines.push('_No threads in inbox_');
+            lines.push('');
+        }
+        else {
+            for (const thread of threads) {
+                const channel = channelInfo[thread.channelId];
+                const channelDetails = !channel ? `(Channel ${thread.channelId})` : '';
+                if (channel) {
+                    thread.title = `[${channel.name}] ${thread.title}`;
+                }
+                const archivedBadge = thread.isArchived ? ' [archived]' : '';
+                const unreadBadge = thread.isUnread ? ' [unread]' : '';
+                const starBadge = thread.isSaved ? ' [saved]' : '';
+                lines.push(`- ${thread.title}${archivedBadge}${unreadBadge}${starBadge}${channelDetails} (ID: ${thread.id})`);
+            }
+            lines.push('');
+        }
+        // Add conversations section only if there are unread conversations
+        if (conversationsWithDetails.length > 0) {
+            lines.push(`## Conversations (${conversationsWithDetails.length})`);
+            lines.push('');
+            for (const convDetail of conversationsWithDetails) {
+                const { conversation, participants } = convDetail;
+                // Build a human-readable title from participant names
+                const participantNames = participants.map((p) => p.fullName);
+                const conversationTitle = conversation.title || describeConversation(participantNames, conversation.id);
+                const unreadBadge = convDetail.isUnread ? ' [unread]' : '';
+                lines.push(`- ${conversationTitle}${unreadBadge} (ID: ${conversation.id})`);
+            }
+            lines.push('');
+        }
+        if (unreadCount > 0 || conversationsWithDetails.length > 0) {
+            lines.push('## Next Steps');
+            lines.push('');
+            lines.push('- Use `load-thread` to read specific threads with their comments');
+            lines.push('- Use `load-conversation` to read specific conversations with their messages');
+            lines.push('- Use `mark-done` to mark items as read and archive them');
+        }
+        const structuredContent = {
+            type: 'inbox_data',
+            workspaceId,
+            threads: threads.map((t) => ({
+                id: t.id,
+                title: t.title,
+                channelId: t.channelId,
+                channelName: channelInfo[t.channelId]?.name,
+                creator: t.creator,
+                isUnread: t.isUnread,
+                isArchived: t.isArchived,
+                isStarred: Boolean(t.isSaved),
+                threadUrl: t.url ??
+                    getFullCommsURL({ workspaceId, channelId: t.channelId, threadId: t.id }),
+            })),
+            conversations: conversationsWithDetails.map((cd) => {
+                const { conversation, participants } = cd;
+                const participantNames = participants.map((p) => p.fullName);
+                return {
+                    id: conversation.id,
+                    title: conversation.title ||
+                        describeConversation(participantNames, conversation.id),
+                    userIds: conversation.userIds,
+                    participantNames,
+                    isUnread: cd.isUnread,
+                    conversationUrl: conversation.url ??
+                        getFullCommsURL({
+                            workspaceId: conversation.workspaceId,
+                            conversationId: conversation.id,
+                        }),
+                };
+            }),
+            unreadCount: unreadThreads.length,
+            unreadThreads: unreadThreadsOriginal,
+            unreadConversations: unreadConversationsOriginal,
+            totalThreads: threads.length,
+            totalConversations: conversationsWithDetails.length,
+        };
+        return {
+            textContent: lines.join('\n'),
+            structuredContent,
+        };
+    },
+};
+export { fetchInbox };

package/dist/tools/get-groups.d.ts

@@ -0,0 +1,62 @@
+import type { CommsApi } from '@doist/comms-sdk';
+import { z } from 'zod';
+import { type GetGroupsOutput } from '../utils/output-schemas.js';
+type GetGroupsStructured = GetGroupsOutput;
+declare const getGroups: {
+    name: "get-groups";
+    description: string;
+    parameters: {
+        workspaceId: z.ZodNumber;
+        groupIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        searchText: z.ZodOptional<z.ZodString>;
+        includeMembers: z.ZodOptional<z.ZodBoolean>;
+    };
+    outputSchema: {
+        type: z.ZodLiteral<"get_groups">;
+        workspaceId: z.ZodNumber;
+        groups: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            workspaceId: z.ZodNumber;
+            memberCount: z.ZodNumber;
+            members: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                id: z.ZodNumber;
+                name: z.ZodOptional<z.ZodString>;
+                email: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>;
+        totalGroups: z.ZodNumber;
+        filteredGroups: z.ZodNumber;
+    };
+    annotations: {
+        readOnlyHint: true;
+        destructiveHint: false;
+        idempotentHint: true;
+    };
+    execute(args: {
+        workspaceId: number;
+        groupIds?: string[] | undefined;
+        searchText?: string | undefined;
+        includeMembers?: boolean | undefined;
+    }, client: CommsApi): Promise<{
+        textContent: string;
+        structuredContent: {
+            type: "get_groups";
+            workspaceId: number;
+            groups: {
+                id: string;
+                name: string;
+                workspaceId: number;
+                memberCount: number;
+                members?: {
+                    id: number;
+                    name?: string | undefined;
+                    email?: string | undefined;
+                }[] | undefined;
+            }[];
+            totalGroups: number;
+            filteredGroups: number;
+        };
+    }>;
+};
+export { getGroups, type GetGroupsStructured };

package/dist/tools/get-groups.js

@@ -0,0 +1,116 @@
+import { z } from 'zod';
+import { degradeAllWithLog, degradeWithLog } from '../utils/degrade.js';
+import { GetGroupsOutputSchema, } from '../utils/output-schemas.js';
+import { ToolNames } from '../utils/tool-names.js';
+const ArgsSchema = {
+    workspaceId: z.number().describe('The workspace ID to get groups from.'),
+    groupIds: z
+        .array(z.string())
+        .optional()
+        .describe('Optional array of specific group IDs to fetch. If not provided or empty array, fetches all workspace groups.'),
+    searchText: z
+        .string()
+        .optional()
+        .describe('Optional search text to filter groups by name (case-insensitive).'),
+    includeMembers: z
+        .boolean()
+        .optional()
+        .describe('When true, list each group\'s members (user ID, name, and email) instead of just a member count. Defaults to false. Use it to answer questions like "who is in the Automations squad?" or to expand a group into individual recipients.'),
+};
+/**
+ * Resolves member user IDs to names/emails with a single workspace-users fetch,
+ * so member lists cost one request regardless of how many groups are returned.
+ *
+ * Returns null when the directory is unreadable (e.g. a token without user
+ * scope). Callers degrade to bare user IDs rather than failing the whole
+ * listing, but say so in the output — unlike list-conversations, where names
+ * are decoration, here the member list is what was asked for, so a silent
+ * drop to IDs would misrepresent the answer.
+ */
+async function fetchMemberLookup(client, workspaceId) {
+    const users = await client.workspaceUsers
+        .getWorkspaceUsers({ workspaceId })
+        .catch(degradeWithLog(ToolNames.GET_GROUPS, 'failed to load workspace roster', { workspaceId }, null));
+    if (!users) {
+        return null;
+    }
+    return new Map(users.map((user) => [
+        user.id,
+        { id: user.id, name: user.fullName, ...(user.email && { email: user.email }) },
+    ]));
+}
+function toMembers(userIds, lookup) {
+    return userIds.map((id) => lookup?.get(id) ?? { id });
+}
+const getGroups = {
+    name: ToolNames.GET_GROUPS,
+    description: 'Get groups from a workspace. Retrieves all workspace groups by default, or specific groups if groupIds array is provided. Supports optional case-insensitive search filtering by group name. Set includeMembers to true to also list who belongs to each group. Use this before passing group IDs to tools that support group notifications.',
+    parameters: ArgsSchema,
+    outputSchema: GetGroupsOutputSchema.shape,
+    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true },
+    async execute(args, client) {
+        const { workspaceId, groupIds, searchText, includeMembers } = args;
+        const requestedGroupIds = groupIds && groupIds.length > 0 ? [...new Set(groupIds)] : undefined;
+        const groups = requestedGroupIds
+            ? (await degradeAllWithLog(ToolNames.GET_GROUPS, 'failed to resolve group', requestedGroupIds, (id) => client.groups.getGroup({ id, workspaceId })))
+                .filter((g) => g !== null)
+                .filter((group) => group.workspaceId === workspaceId)
+            : await client.groups.getGroups(workspaceId);
+        const totalGroups = groups.length;
+        let filteredGroups = groups;
+        if (searchText) {
+            const searchLower = searchText.toLowerCase();
+            filteredGroups = groups.filter((group) => group.name.toLowerCase().includes(searchLower));
+        }
+        // Nothing to resolve if every matched group is empty, so skip the directory read.
+        const hasMembersToResolve = filteredGroups.some((group) => group.userIds.length > 0);
+        const memberLookup = includeMembers && hasMembersToResolve
+            ? await fetchMemberLookup(client, workspaceId)
+            : undefined;
+        const membersUnresolved = memberLookup === null;
+        const lines = ['# Workspace Groups', ''];
+        lines.push(`**Workspace ID:** ${workspaceId}`);
+        lines.push(`**Total Groups:** ${totalGroups}${searchText ? ` (${filteredGroups.length} matching search)` : ''}`);
+        if (membersUnresolved) {
+            lines.push('**Note:** Member names could not be looked up (the workspace directory was unavailable), so members are listed by user ID only.');
+        }
+        lines.push('');
+        if (filteredGroups.length === 0) {
+            lines.push('No groups found.');
+        }
+        else {
+            for (const group of filteredGroups) {
+                lines.push(`## ${group.name}`);
+                lines.push(`**ID:** ${group.id}`);
+                lines.push(`**Members:** ${group.userIds.length}`);
+                if (includeMembers) {
+                    for (const member of toMembers(group.userIds, memberLookup)) {
+                        const name = member.name ?? `user:${member.id}`;
+                        const email = member.email ? ` <${member.email}>` : '';
+                        lines.push(`- ${name} (id:${member.id})${email}`);
+                    }
+                }
+                lines.push('');
+            }
+        }
+        const textContent = lines.join('\n');
+        const structuredContent = {
+            type: 'get_groups',
+            workspaceId,
+            groups: filteredGroups.map((group) => ({
+                id: group.id,
+                name: group.name,
+                workspaceId: group.workspaceId,
+                memberCount: group.userIds.length,
+                ...(includeMembers && { members: toMembers(group.userIds, memberLookup) }),
+            })),
+            totalGroups,
+            filteredGroups: filteredGroups.length,
+        };
+        return {
+            textContent,
+            structuredContent,
+        };
+    },
+};
+export { getGroups };

package/dist/tools/get-mentions.d.ts

@@ -0,0 +1,97 @@
+import { z } from 'zod';
+import { type GetMentionsOutput } from '../utils/output-schemas.js';
+type GetMentionsStructured = GetMentionsOutput;
+declare const getMentions: {
+    name: "get-mentions";
+    description: string;
+    parameters: {
+        workspaceId: z.ZodNumber;
+        channelIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        authorIds: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+        dateFrom: z.ZodOptional<z.ZodString>;
+        dateTo: z.ZodOptional<z.ZodString>;
+        limit: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        cursor: z.ZodOptional<z.ZodString>;
+    };
+    outputSchema: {
+        type: z.ZodLiteral<"mentions_results">;
+        workspaceId: z.ZodNumber;
+        results: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"thread">;
+            threadId: z.ZodString;
+            commentId: z.ZodOptional<z.ZodString>;
+            channelId: z.ZodOptional<z.ZodString>;
+            channelName: z.ZodOptional<z.ZodString>;
+            id: z.ZodString;
+            content: z.ZodString;
+            creatorId: z.ZodNumber;
+            creatorName: z.ZodOptional<z.ZodString>;
+            created: z.ZodString;
+            workspaceId: z.ZodNumber;
+            url: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"conversation">;
+            conversationId: z.ZodString;
+            messageId: z.ZodString;
+            id: z.ZodString;
+            content: z.ZodString;
+            creatorId: z.ZodNumber;
+            creatorName: z.ZodOptional<z.ZodString>;
+            created: z.ZodString;
+            workspaceId: z.ZodNumber;
+            url: z.ZodString;
+        }, z.core.$strip>], "type">>;
+        totalResults: z.ZodNumber;
+        hasMore: z.ZodBoolean;
+        cursor: z.ZodOptional<z.ZodString>;
+    };
+    annotations: {
+        readOnlyHint: true;
+        destructiveHint: false;
+        idempotentHint: true;
+    };
+    execute(args: {
+        workspaceId: number;
+        limit: number;
+        channelIds?: string[] | undefined;
+        authorIds?: number[] | undefined;
+        dateFrom?: string | undefined;
+        dateTo?: string | undefined;
+        cursor?: string | undefined;
+    }, client: import("@doist/comms-sdk").CommsApi): Promise<{
+        textContent: string;
+        structuredContent: {
+            type: "mentions_results";
+            workspaceId: number;
+            results: ({
+                type: "thread";
+                threadId: string;
+                id: string;
+                content: string;
+                creatorId: number;
+                created: string;
+                workspaceId: number;
+                url: string;
+                commentId?: string | undefined;
+                channelId?: string | undefined;
+                channelName?: string | undefined;
+                creatorName?: string | undefined;
+            } | {
+                type: "conversation";
+                conversationId: string;
+                messageId: string;
+                id: string;
+                content: string;
+                creatorId: number;
+                created: string;
+                workspaceId: number;
+                url: string;
+                creatorName?: string | undefined;
+            })[];
+            totalResults: number;
+            hasMore: boolean;
+            cursor?: string | undefined;
+        };
+    }>;
+};
+export { getMentions, type GetMentionsStructured };

package/dist/tools/get-mentions.js

@@ -0,0 +1,126 @@
+import { z } from 'zod';
+import { degradeAllWithLog, resolveUsersWithLog } from '../utils/degrade.js';
+import { GetMentionsOutputSchema } from '../utils/output-schemas.js';
+import { toRawSearchResults, toSearchResultItems } from '../utils/search-results.js';
+import { ToolNames } from '../utils/tool-names.js';
+const ArgsSchema = {
+    workspaceId: z.number().describe('The workspace ID to search in.'),
+    channelIds: z.array(z.string()).optional().describe('Filter by channel IDs.'),
+    authorIds: z.array(z.number()).optional().describe('Filter by author user IDs.'),
+    dateFrom: z.string().optional().describe('Start date for filtering (YYYY-MM-DD).'),
+    dateTo: z.string().optional().describe('End date for filtering (YYYY-MM-DD).'),
+    limit: z
+        .number()
+        .int()
+        .min(1)
+        .max(100)
+        .optional()
+        .default(50)
+        .describe('Maximum number of results to return.'),
+    cursor: z.string().optional().describe('Cursor for pagination.'),
+};
+const getMentions = {
+    name: ToolNames.GET_MENTIONS,
+    description: 'Fetch threads, comments, and messages that mention the current user. Supports filtering by channel, author, and date range. Use this instead of search-content when no keyword query is needed.',
+    parameters: ArgsSchema,
+    outputSchema: GetMentionsOutputSchema.shape,
+    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true },
+    async execute(args, client) {
+        const { workspaceId, channelIds, authorIds, dateFrom, dateTo, limit, cursor } = args;
+        const response = await client.search.search({
+            workspaceId,
+            mentionSelf: true,
+            channelIds,
+            authorIds,
+            dateFrom,
+            dateTo,
+            limit,
+            cursor,
+        });
+        const results = toRawSearchResults(response.items, 'get-mentions');
+        const hasMore = response.hasMore;
+        const responseCursor = response.nextCursorMark;
+        const userLookup = {};
+        let channelLookup = {};
+        if (results.length > 0) {
+            const userIds = new Set();
+            const channelIdSet = new Set();
+            for (const result of results) {
+                userIds.add(result.creatorId);
+                if (result.type === 'thread' && result.channelId) {
+                    channelIdSet.add(result.channelId);
+                }
+            }
+            const uniqueUserIds = Array.from(userIds);
+            const uniqueChannelIds = Array.from(channelIdSet);
+            const [users, channels] = await Promise.all([
+                resolveUsersWithLog(client, ToolNames.GET_MENTIONS, 'failed to resolve mention author', workspaceId, uniqueUserIds),
+                degradeAllWithLog(ToolNames.GET_MENTIONS, 'failed to resolve channel', uniqueChannelIds, (id) => client.channels.getChannel(id)),
+            ]);
+            for (const [id, user] of users) {
+                userLookup[id] = user.fullName;
+            }
+            channelLookup = channels.reduce((acc, channel) => {
+                if (channel)
+                    acc[channel.id] = channel.name;
+                return acc;
+            }, {});
+        }
+        const lines = [`# Mentions in Workspace ${workspaceId}`, ''];
+        lines.push(`**Results Found:** ${results.length}`);
+        lines.push(`**More Available:** ${hasMore ? 'Yes' : 'No'}`);
+        lines.push('');
+        if (results.length === 0) {
+            lines.push('_No mentions found_');
+        }
+        else {
+            lines.push('## Results');
+            lines.push('');
+            for (const result of results) {
+                const date = result.created.split('T')[0];
+                const typeLabel = result.type.charAt(0).toUpperCase() + result.type.slice(1);
+                const creatorName = userLookup[result.creatorId];
+                lines.push(`### ${typeLabel} ${result.id}`);
+                lines.push(`**Created:** ${date} | **Creator:** ${creatorName} (${result.creatorId})`);
+                if (result.type === 'thread') {
+                    lines.push(`**Thread:** ${result.threadId}`);
+                    if (result.commentId) {
+                        lines.push(`**Comment:** ${result.commentId}`);
+                    }
+                    if (result.channelId) {
+                        const channelName = channelLookup[result.channelId];
+                        lines.push(`**Channel:** ${channelName} (${result.channelId})`);
+                    }
+                }
+                else {
+                    lines.push(`**Conversation:** ${result.conversationId}`);
+                    lines.push(`**Message:** ${result.messageId}`);
+                }
+                lines.push('');
+                const contentPreview = result.content.length > 200
+                    ? `${result.content.substring(0, 200)}...`
+                    : result.content;
+                lines.push(contentPreview);
+                lines.push('');
+            }
+        }
+        if (hasMore) {
+            lines.push('## Next Steps');
+            lines.push('');
+            lines.push('More results available. Use the cursor to fetch the next page.');
+        }
+        const structuredContent = {
+            type: 'mentions_results',
+            workspaceId,
+            results: toSearchResultItems(results, { workspaceId, userLookup, channelLookup }),
+            totalResults: results.length,
+            hasMore,
+            cursor: responseCursor,
+        };
+        return {
+            textContent: lines.join('\n'),
+            structuredContent,
+        };
+    },
+};
+export { getMentions };