@hailer/mcp 0.1.6 → 0.1.9

package/dist/mcp/tools/discussion.js

@@ -102,21 +102,29 @@ exports.listMyDiscussionsTool = {
                 .map((d) => d.linked_activity);
             // Fetch activity names in parallel for better UX
             const activityNames = {};
+            const activityErrors = [];
             if (activityIds.length > 0) {
                 const activityPromises = activityIds.map(async (activityId) => {
                     try {
                         const activity = await context.hailer.fetchActivityById(activityId);
-                        return { id: activityId, name: activity?.name || null };
+                        return { id: activityId, name: activity?.name || null, error: null };
                     }
                     catch (error) {
-                        logger.debug('Failed to fetch activity name', { activityId, error });
-                        return { id: activityId, name: null };
+                        const errorMsg = error instanceof Error ? error.message :
+                            (typeof error === 'object' && error !== null && 'msg' in error) ? error.msg :
+                                String(error);
+                        logger.debug('Failed to fetch activity name', { activityId, error: errorMsg });
+                        return { id: activityId, name: null, error: errorMsg };
                     }
                 });
                 const results = await Promise.all(activityPromises);
-                results.forEach(({ id, name }) => {
-                    if (name)
+                results.forEach(({ id, name, error }) => {
+                    if (name) {
                         activityNames[id] = name;
+                    }
+                    else if (error) {
+                        activityErrors.push({ id, error });
+                    }
                 });
             }
             const discussionsByType = {
@@ -191,6 +199,14 @@ exports.listMyDiscussionsTool = {
                 }
             }
             responseText += `- Total unread: ${totalUnread}\n`;
+            // Add warnings section if there were errors loading activities
+            if (activityErrors.length > 0) {
+                responseText += `\n⚠️ **WARNINGS** (${activityErrors.length} activity/activities failed to load):\n`;
+                activityErrors.forEach(({ id, error }) => {
+                    responseText += `- Activity \`${id}\`: ${error}\n`;
+                });
+                responseText += `\n💡 These activities may have broken function fields or permission issues.\n`;
+            }
             responseText += `\n💡 **USAGE:**\n`;
             responseText += `- Use \`fetch_discussion_messages\` with discussion ID to read messages\n`;
             responseText += `- Use \`add_discussion_message\` with discussion ID to post a message\n`;
@@ -241,13 +257,46 @@ exports.fetchDiscussionMessagesTool = {
     }),
     async execute(args, context) {
         const limit = args.limit || 50;
+        let discussionId = args.discussionId;
         logger.debug('Fetching discussion messages', {
-            discussionId: args.discussionId,
+            discussionId: discussionId,
             limit: limit,
             apiKey: context.apiKey.substring(0, 8) + '...'
         });
         try {
-            const result = await context.hailer.fetchDiscussionMessages(args.discussionId, limit);
+            // Auto-detect: if this is an activity ID, get its discussion ID
+            // Try fetching as discussion first, if it fails, check if it's an activity
+            let result;
+            try {
+                result = await context.hailer.fetchDiscussionMessages(discussionId, limit);
+            }
+            catch (firstError) {
+                // If first attempt fails, try loading as activity to get discussion ID
+                logger.debug('First fetch failed, checking if this is an activity ID', {
+                    providedId: discussionId,
+                    error: firstError?.msg || firstError?.message
+                });
+                try {
+                    const activity = await context.hailer.fetchActivityById(discussionId);
+                    if (activity?.discussion) {
+                        logger.info('Auto-converted activity ID to discussion ID', {
+                            activityId: discussionId,
+                            discussionId: activity.discussion,
+                            activityName: activity.name
+                        });
+                        discussionId = activity.discussion;
+                        result = await context.hailer.fetchDiscussionMessages(discussionId, limit);
+                    }
+                    else {
+                        // Not an activity or no discussion linked, rethrow original error
+                        throw firstError;
+                    }
+                }
+                catch (activityError) {
+                    // Activity lookup failed too, rethrow original error
+                    throw firstError;
+                }
+            }
             const messages = result.messages || [];
             const messageCount = messages.length;
             const userMessages = messages.filter((m) => m.type === "user");
@@ -266,6 +315,7 @@ exports.fetchDiscussionMessagesTool = {
                 }
                 const optimizedMsg = {
                     _id: msg._id,
+                    uid: msg.uid, // Include user ID for conversation history
                     username: username,
                     created: new Date(msg.created).toLocaleString(),
                     type: msg.type,
@@ -394,6 +444,7 @@ exports.fetchPreviousDiscussionMessagesTool = {
                 }
                 const optimizedMsg = {
                     _id: msg._id,
+                    uid: msg.uid, // Include user ID for conversation history
                     username: username,
                     created: new Date(msg.created).toLocaleString(),
                     msg: cleanMsg
@@ -454,7 +505,18 @@ exports.fetchPreviousDiscussionMessagesTool = {
 // ============================================================================
 // TOOL 4: JOIN DISCUSSION
 // ============================================================================
-const joinDiscussionDescription = `Join a discussion to gain access to read and post messages - Use this for activity discussions (provide activityId) or general discussions (provide discussionId)`;
+const joinDiscussionDescription = `<purpose>Join a discussion (bot joins) and optionally invite a user</purpose>
+<when-to-use>
+  <case>Activity discussions: provide activityId</case>
+  <case>General discussions: provide discussionId</case>
+</when-to-use>
+<critical>
+  When user says "invite me" or asks to be added to a discussion:
+  - Extract user_id from the incoming message → inviteUserId
+  - Extract source activity from current discussion → sourceActivityId (for wormhole link back)
+  - Provide context explaining WHY → welcomeReason
+  - Bot joins FIRST, then invites user, then posts welcome message with wormhole
+</critical>`;
 exports.joinDiscussionTool = {
     name: 'join_discussion',
     group: tool_registry_1.ToolGroup.WRITE,
@@ -469,7 +531,21 @@ exports.joinDiscussionTool = {
             .string()
             .min(24, "Discussion ID must be at least 24 characters")
             .optional()
-            .describe("Discussion ID to join directly (use this for non-activity discussions)")
+            .describe("Discussion ID to join directly (use this for non-activity discussions)"),
+        inviteUserId: zod_1.z
+            .string()
+            .min(24, "User ID must be at least 24 characters")
+            .optional()
+            .describe("User ID to invite. Get from incoming message user_id attribute when user asks to be invited."),
+        welcomeReason: zod_1.z
+            .string()
+            .optional()
+            .describe("Context/reason for the invite - posted as welcome message in the discussion."),
+        sourceActivityId: zod_1.z
+            .string()
+            .min(24)
+            .optional()
+            .describe("IMPORTANT: The activity_id from the CURRENT discussion where the request was made. This creates a 'came from' link in the welcome message. Get this from the incoming message's activity_id attribute.")
     }).refine((data) => data.activityId || data.discussionId, {
         message: "Either activityId or discussionId must be provided"
     }),
@@ -477,57 +553,207 @@ exports.joinDiscussionTool = {
         logger.debug('Joining discussion', {
             activityId: args.activityId,
             discussionId: args.discussionId,
+            inviteUserId: args.inviteUserId,
             apiKey: context.apiKey.substring(0, 8) + '...'
         });
         try {
+            let discussionId;
+            let activityName;
+            let resolvedActivityId;
             if (args.activityId) {
                 const result = await context.hailer.joinActivityDiscussion(args.activityId);
                 const activity = await context.hailer.fetchActivityById(args.activityId);
-                const discussionId = activity.discussion;
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: `✅ Successfully joined activity discussion!\n\n` +
-                                `📋 **Activity**: ${activity.name || args.activityId}\n` +
-                                `💬 **Discussion ID**: ${discussionId}\n` +
-                                `📊 **Status**: ${result ? 'Now following this activity' : 'Already following'}\n\n` +
-                                `🎉 You can now:\n` +
-                                `- Read messages with: fetch_discussion_messages(discussionId: "${discussionId}")\n` +
-                                `- Post messages with: add_discussion_message(discussionId: "${discussionId}", content: "your message")\n` +
-                                `- Leave with: leave_discussion(activityId: "${args.activityId}")\n\n` +
-                                `🔗 **Direct Links:**\n` +
-                                `- Activity: https://app.hailer.com/#/activities/${args.activityId}\n` +
-                                `- Discussion: https://app.hailer.com/#/discussions/${discussionId}`,
-                        },
-                    ],
-                };
+                discussionId = activity.discussion;
+                activityName = activity.name;
+                resolvedActivityId = args.activityId;
+                logger.debug('Joined activity discussion', {
+                    activityId: args.activityId,
+                    discussionId,
+                    activityName,
+                    followResult: result
+                });
             }
-            if (args.discussionId) {
-                const result = await context.hailer.joinDiscussion(args.discussionId);
+            else if (args.discussionId) {
+                // Try joining as discussion first
+                try {
+                    await context.hailer.joinDiscussion(args.discussionId);
+                    discussionId = args.discussionId;
+                    logger.debug('Joined discussion directly', {
+                        discussionId
+                    });
+                }
+                catch (directJoinError) {
+                    // If direct join fails, try treating the ID as an activity ID
+                    logger.debug('Direct discussion join failed, trying as activity ID', {
+                        providedId: args.discussionId,
+                        error: directJoinError?.msg || directJoinError?.message
+                    });
+                    try {
+                        const activity = await context.hailer.fetchActivityById(args.discussionId);
+                        if (activity?.discussion) {
+                            // It's an activity! Join its discussion
+                            await context.hailer.joinActivityDiscussion(args.discussionId);
+                            discussionId = activity.discussion;
+                            activityName = activity.name;
+                            resolvedActivityId = args.discussionId;
+                            logger.info('Auto-resolved activity ID to discussion', {
+                                activityId: args.discussionId,
+                                discussionId,
+                                activityName
+                            });
+                        }
+                        else {
+                            // Not an activity either, rethrow original error
+                            throw directJoinError;
+                        }
+                    }
+                    catch (activityError) {
+                        // Activity lookup also failed, rethrow original error
+                        logger.debug('Activity lookup also failed', {
+                            error: activityError?.msg || activityError?.message
+                        });
+                        throw directJoinError;
+                    }
+                }
+            }
+            else {
                 return {
-                    content: [
-                        {
+                    content: [{
                             type: "text",
-                            text: `✅ ${result.message}\n\n` +
-                                `💬 **Discussion ID**: ${args.discussionId}\n` +
-                                `📊 **Method**: ${result.method}\n\n` +
-                                `🎉 You can now:\n` +
-                                `- Read messages with: fetch_discussion_messages(discussionId: "${args.discussionId}")\n` +
-                                `- Post messages with: add_discussion_message(discussionId: "${args.discussionId}", content: "your message")\n\n` +
-                                `💡 **Note**: For activity discussions, prefer using activityId for better integration.\n\n` +
-                                `🔗 **Direct Link:** https://app.hailer.com/#/discussions/${args.discussionId}`,
-                        },
-                    ],
+                            text: `❌ Error: Either activityId or discussionId must be provided`,
+                        }],
                 };
             }
+            // Invite the requesting user if provided
+            let userInvited = false;
+            let userAlreadyMember = false;
+            let invitedUserName = '';
+            if (args.inviteUserId) {
+                try {
+                    // Get user name first
+                    const userInfo = (0, workspace_cache_1.getUserById)(context.workspaceCache, args.inviteUserId);
+                    invitedUserName = userInfo
+                        ? `${userInfo.firstname || ''} ${userInfo.lastname || ''}`.trim() || userInfo.fullName || args.inviteUserId
+                        : args.inviteUserId;
+                    // Check if user is already a member
+                    const syncResponse = await context.hailer.request('messenger.load_discussions', [
+                        [discussionId]
+                    ]);
+                    const discussion = syncResponse?.[discussionId];
+                    const existingMembers = new Set(discussion?.participants || []);
+                    if (existingMembers.has(args.inviteUserId)) {
+                        userAlreadyMember = true;
+                        logger.debug('User already a member, skipping invite', {
+                            discussionId,
+                            userId: args.inviteUserId,
+                            userName: invitedUserName
+                        });
+                    }
+                    else {
+                        logger.debug('Inviting user to discussion', {
+                            discussionId,
+                            userId: args.inviteUserId
+                        });
+                        await context.hailer.request('messenger.invite_users', [
+                            discussionId,
+                            [args.inviteUserId]
+                        ]);
+                        userInvited = true;
+                        logger.debug('User invited successfully', {
+                            discussionId,
+                            userId: args.inviteUserId,
+                            userName: invitedUserName
+                        });
+                    }
+                    // Post welcome message if reason provided
+                    if (args.welcomeReason) {
+                        try {
+                            // Format user tag properly: [hailerTag|Name](userId) with ZWNBSP
+                            const ZWNBSP = '\uFEFF';
+                            const userTag = `${ZWNBSP}[hailerTag|${invitedUserName}](${args.inviteUserId})${ZWNBSP}`;
+                            // Format source activity tag (where request came from)
+                            // IMPORTANT: Ignore sourceActivityId if it equals the destination activityId
+                            // (LLM sometimes confuses source/destination)
+                            let sourceTag = '';
+                            const validSourceId = args.sourceActivityId && args.sourceActivityId !== args.activityId
+                                ? args.sourceActivityId
+                                : null;
+                            if (validSourceId) {
+                                try {
+                                    const sourceActivity = await context.hailer.fetchActivityById(validSourceId);
+                                    const sourceActivityName = sourceActivity?.name || 'Unknown';
+                                    sourceTag = `${ZWNBSP}[hailerTag|${sourceActivityName}](${validSourceId})${ZWNBSP}`;
+                                }
+                                catch {
+                                    sourceTag = `activity ${validSourceId}`;
+                                }
+                            }
+                            // Build welcome message - focus on WHERE they came from
+                            let welcomeMsg;
+                            if (sourceTag) {
+                                welcomeMsg = `👋 ${userTag} joined from ${sourceTag}\n\n**Context:** ${args.welcomeReason}`;
+                            }
+                            else {
+                                welcomeMsg = `👋 ${userTag} was added to this discussion.\n\n**Context:** ${args.welcomeReason}`;
+                            }
+                            // Build links metadata for tags
+                            const links = [
+                                { target: args.inviteUserId, targetType: 'user', type: 'linked-to' }
+                            ];
+                            if (args.activityId) {
+                                links.push({ target: args.activityId, targetType: 'activity', type: 'linked-to' });
+                            }
+                            if (validSourceId) {
+                                links.push({ target: validSourceId, targetType: 'activity', type: 'linked-to' });
+                            }
+                            await context.hailer.request('messenger.send', [
+                                { msg: welcomeMsg, links },
+                                discussionId
+                            ]);
+                            logger.debug('Welcome message posted', { discussionId, hadTags: true, hasWormhole: !!validSourceId });
+                        }
+                        catch (welcomeError) {
+                            logger.warn('Failed to post welcome message', {
+                                discussionId,
+                                error: welcomeError instanceof Error ? welcomeError.message : String(welcomeError)
+                            });
+                        }
+                    }
+                }
+                catch (inviteError) {
+                    logger.warn('Failed to invite user', {
+                        discussionId,
+                        userId: args.inviteUserId,
+                        error: inviteError instanceof Error ? inviteError.message : String(inviteError)
+                    });
+                }
+            }
+            // Build response
+            let responseText = `✅ Successfully joined discussion!\n\n`;
+            if (activityName) {
+                responseText += `📋 **Activity**: ${activityName}\n`;
+            }
+            responseText += `💬 **Discussion ID**: ${discussionId}\n`;
+            if (userInvited) {
+                responseText += `👤 **User Invited**: ${invitedUserName} ✅\n`;
+            }
+            else if (userAlreadyMember) {
+                responseText += `👤 **User**: ${invitedUserName} (already a member)\n`;
+            }
+            responseText += `\n🎉 You can now:\n`;
+            responseText += `- Read messages with: fetch_discussion_messages(discussionId: "${discussionId}")\n`;
+            responseText += `- Post messages with: add_discussion_message(discussionId: "${discussionId}", content: "your message")\n`;
+            if (resolvedActivityId) {
+                responseText += `- Leave with: leave_discussion(activityId: "${resolvedActivityId}")\n`;
+                responseText += `\n🔗 **Direct Links:**\n`;
+                responseText += `- Activity: https://app.hailer.com/#/activities/${resolvedActivityId}\n`;
+            }
+            responseText += `- Discussion: https://app.hailer.com/#/discussions/${discussionId}`;
             return {
-                content: [
-                    {
+                content: [{
                         type: "text",
-                        text: `❌ Error: Either activityId or discussionId must be provided`,
-                    },
-                ],
+                        text: responseText,
+                    }],
             };
         }
         catch (error) {
@@ -549,7 +775,8 @@ exports.joinDiscussionTool = {
                             `- Some discussions may be private or require an invitation\n\n` +
                             `📖 Examples:\n` +
                             `- Activity discussion: join_discussion(activityId: "68446dc05b30685f67c6fcd4")\n` +
-                            `- General discussion: join_discussion(discussionId: "683ef53087e3d8329abaa3ad")`,
+                            `- General discussion: join_discussion(discussionId: "683ef53087e3d8329abaa3ad")\n` +
+                            `- With user invite: join_discussion(activityId: "...", inviteUserId: "user-id-from-context")`,
                     },
                 ],
             };
@@ -725,35 +952,83 @@ exports.inviteDiscussionMembersTool = {
             apiKey: context.apiKey.substring(0, 8) + '...'
         });
         try {
-            // Use messenger.invite_users endpoint
-            const result = await context.hailer.request('messenger.invite_users', [
-                args.discussionId,
-                args.userIds
+            // First, check who is already a member
+            const syncResponse = await context.hailer.request('messenger.load_discussions', [
+                [args.discussionId]
             ]);
-            logger.debug('Invite result', { result });
-            // Get usernames for better feedback
-            const invitedUsers = args.userIds.map((userId) => {
+            const discussion = syncResponse?.[args.discussionId];
+            // Block invites to private chats - this breaks Hailer
+            if (discussion?.private === true) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `❌ Cannot invite members to a private chat.\n\n` +
+                                `Private chats are 1-on-1 conversations and cannot have additional members.\n` +
+                                `💡 To include more people, create a group discussion instead.`
+                        }]
+                };
+            }
+            const existingMembers = new Set(discussion?.participants || []);
+            // Filter out users who are already members
+            const alreadyMembers = [];
+            const newUsers = [];
+            for (const userId of args.userIds) {
+                if (existingMembers.has(userId)) {
+                    alreadyMembers.push(userId);
+                }
+                else {
+                    newUsers.push(userId);
+                }
+            }
+            logger.debug('Membership check', {
+                discussionId: args.discussionId,
+                existingMemberCount: existingMembers.size,
+                alreadyMembers: alreadyMembers.length,
+                newUsers: newUsers.length
+            });
+            // Helper to get user display name
+            const getUserName = (userId) => {
                 const userInfo = (0, workspace_cache_1.getUserById)(context.workspaceCache, userId);
-                const fullName = userInfo
-                    ? `${userInfo.firstname || ''} ${userInfo.lastname || ''}`.trim() || userInfo.fullName
+                return userInfo
+                    ? `${userInfo.firstname || ''} ${userInfo.lastname || ''}`.trim() || userInfo.fullName || userId
                     : userId;
-                return `- ${fullName} (${userId})`;
-            }).join('\n');
+            };
+            // If all users are already members, return early
+            if (newUsers.length === 0) {
+                const alreadyMembersList = alreadyMembers.map((userId) => `- ${getUserName(userId)} (${userId})`).join('\n');
+                return {
+                    content: [{
+                            type: "text",
+                            text: `ℹ️ All users are already members of this discussion!\n\n` +
+                                `💬 **Discussion ID**: ${args.discussionId}\n` +
+                                `👥 **Already Members**:\n${alreadyMembersList}\n\n` +
+                                `💡 No invites were sent - these users can already participate.`
+                        }]
+                };
+            }
+            // Invite only the new users
+            const result = await context.hailer.request('messenger.invite_users', [
+                args.discussionId,
+                newUsers
+            ]);
+            logger.debug('Invite result', { result, invitedCount: newUsers.length });
+            // Build response
+            const invitedUsersList = newUsers.map((userId) => `- ${getUserName(userId)} (${userId})`).join('\n');
+            let responseText = `✅ Successfully invited ${newUsers.length} member(s) to discussion!\n\n` +
+                `💬 **Discussion ID**: ${args.discussionId}\n` +
+                `👥 **Invited Members**:\n${invitedUsersList}\n`;
+            // Note if some were already members
+            if (alreadyMembers.length > 0) {
+                const alreadyMembersList = alreadyMembers.map((userId) => `- ${getUserName(userId)}`).join('\n');
+                responseText += `\nℹ️ **Already Members** (skipped):\n${alreadyMembersList}\n`;
+            }
+            responseText += `\n🎉 The invited members can now:\n` +
+                `- See all messages in the discussion\n` +
+                `- Post messages and participate\n` +
+                `- Receive notifications for new activity\n\n` +
+                `🔗 **Discussion Link:** https://app.hailer.com/#/discussions/${args.discussionId}`;
             return {
-                content: [
-                    {
-                        type: "text",
-                        text: `✅ Successfully invited ${args.userIds.length} member(s) to discussion!\n\n` +
-                            `💬 **Discussion ID**: ${args.discussionId}\n` +
-                            `👥 **Invited Members**:\n${invitedUsers}\n\n` +
-                            `🎉 The invited members can now:\n` +
-                            `- See all messages in the discussion\n` +
-                            `- Post messages and participate\n` +
-                            `- Receive notifications for new activity\n\n` +
-                            `💡 **Use Case**: Perfect for bringing specialized bots or team members into conversations!\n\n` +
-                            `🔗 **Discussion Link:** https://app.hailer.com/#/discussions/${args.discussionId}`,
-                    },
-                ],
+                content: [{ type: "text", text: responseText }],
             };
         }
         catch (error) {