@burdenoff/mcp-libs 2026.523.1 → 2026.525.1

package/dist/modules/conversations/index.js

@@ -71,6 +71,283 @@ var UPDATE_CONVERSATION_SETTINGS = `
     }
   }
 `;
+var GET_MESSAGE = `
+  query Message($id: ID!) {
+    message(id: $id) {
+      id conversationId authorId authorType content type status
+      isEdited isPinned isHidden createdAt updatedAt
+    }
+  }
+`;
+var EDIT_MESSAGE = `
+  mutation EditMessage($input: EditMessageInput!) {
+    editMessage(input: $input) {
+      id content isEdited editedAt updatedAt
+    }
+  }
+`;
+var DELETE_MESSAGE = `
+  mutation DeleteMessage($id: ID!, $hard: Boolean) {
+    deleteMessage(id: $id, hard: $hard) { success messageId }
+  }
+`;
+var FORWARD_MESSAGE = `
+  mutation ForwardMessage($messageId: ID!, $targetConversationId: ID!) {
+    forwardMessage(messageId: $messageId, targetConversationId: $targetConversationId) {
+      success
+      message { id conversationId content type createdAt }
+    }
+  }
+`;
+var PIN_MESSAGE = `
+  mutation PinMessage($messageId: ID!) {
+    pinMessage(messageId: $messageId) { id isPinned pinnedAt }
+  }
+`;
+var UNPIN_MESSAGE = `
+  mutation UnpinMessage($messageId: ID!) {
+    unpinMessage(messageId: $messageId) { id isPinned pinnedAt }
+  }
+`;
+var HIDE_MESSAGE = `
+  mutation HideMessage($messageId: ID!, $reason: String!) {
+    hideMessage(messageId: $messageId, reason: $reason) { id isHidden }
+  }
+`;
+var UNHIDE_MESSAGE = `
+  mutation UnhideMessage($messageId: ID!) {
+    unhideMessage(messageId: $messageId) { id isHidden }
+  }
+`;
+var SEARCH_MESSAGES = `
+  query SearchMessages($query: String!, $conversationId: ID, $first: Int, $after: String) {
+    searchMessages(query: $query, conversationId: $conversationId, first: $first, after: $after) {
+      edges { cursor node { id conversationId authorId content type createdAt } }
+      pageInfo { hasNextPage endCursor }
+      totalCount
+    }
+  }
+`;
+var UNREAD_MESSAGES = `
+  query UnreadMessages($first: Int, $after: String) {
+    unreadMessages(first: $first, after: $after) {
+      edges { cursor node { id conversationId authorId content type createdAt } }
+      pageInfo { hasNextPage endCursor }
+      totalCount
+    }
+  }
+`;
+var REPORT_MESSAGE = `
+  mutation ReportMessage($messageId: ID!, $reason: String!) {
+    reportMessage(messageId: $messageId, reason: $reason) {
+      success messageId reportId
+    }
+  }
+`;
+var GET_DRAFT = `
+  query Draft($conversationId: ID!) {
+    draft(conversationId: $conversationId) {
+      id conversationId userId content parentMessageId createdAt updatedAt
+    }
+  }
+`;
+var SAVE_DRAFT = `
+  mutation SaveDraft($input: SaveDraftInput!) {
+    saveDraft(input: $input) {
+      id conversationId userId content parentMessageId createdAt updatedAt
+    }
+  }
+`;
+var DELETE_DRAFT = `
+  mutation DeleteDraft($conversationId: ID!) {
+    deleteDraft(conversationId: $conversationId) { success conversationId }
+  }
+`;
+var ADD_REACTION = `
+  mutation AddReaction($messageId: ID!, $emoji: String!) {
+    addReaction(messageId: $messageId, emoji: $emoji) {
+      id messageId userId emoji createdAt
+    }
+  }
+`;
+var REMOVE_REACTION = `
+  mutation RemoveReaction($messageId: ID!, $emoji: String!) {
+    removeReaction(messageId: $messageId, emoji: $emoji) {
+      success messageId emoji
+    }
+  }
+`;
+var GET_THREAD = `
+  query Thread($messageId: ID!, $first: Int, $after: String) {
+    thread(messageId: $messageId, first: $first, after: $after) {
+      edges { cursor node { id conversationId authorId content type createdAt threadRootId parentMessageId } }
+      pageInfo { hasNextPage endCursor }
+      totalCount
+    }
+  }
+`;
+var GET_OR_CREATE_DIRECT_CONVERSATION = `
+  mutation GetOrCreateDirectConversation($userId: ID!) {
+    getOrCreateDirectConversation(userId: $userId) {
+      id title type createdAt
+    }
+  }
+`;
+var LIST_MENTIONS = `
+  query Mentions($first: Int, $after: String, $unreadOnly: Boolean) {
+    mentions(first: $first, after: $after, unreadOnly: $unreadOnly) {
+      edges { cursor node { id conversationId authorId content type createdAt } }
+      pageInfo { hasNextPage endCursor }
+      totalCount
+    }
+  }
+`;
+var SEARCH_CONVERSATIONS = `
+  query SearchConversations($query: String!, $first: Int, $after: String) {
+    searchConversations(query: $query, first: $first, after: $after) {
+      edges { cursor node { id title type description createdAt updatedAt unreadCount } }
+      pageInfo { hasNextPage endCursor }
+      totalCount
+    }
+  }
+`;
+var GET_PRESENCE = `
+  query Presence($userIds: [ID!]!) {
+    presence(userIds: $userIds) {
+      userId status customStatus lastSeenAt
+    }
+  }
+`;
+var UPDATE_PRESENCE = `
+  mutation UpdatePresence($status: PresenceStatus!, $customStatus: String) {
+    updatePresence(status: $status, customStatus: $customStatus) {
+      userId status customStatus lastSeenAt
+    }
+  }
+`;
+var LIST_TYPING_INDICATORS = `
+  query TypingIndicators($conversationId: ID!) {
+    typingIndicators(conversationId: $conversationId) {
+      conversationId userId startedAt
+    }
+  }
+`;
+var START_TYPING = `
+  mutation StartTyping($conversationId: ID!) {
+    startTyping(conversationId: $conversationId)
+  }
+`;
+var STOP_TYPING = `
+  mutation StopTyping($conversationId: ID!) {
+    stopTyping(conversationId: $conversationId)
+  }
+`;
+var ADD_PARTICIPANT = `
+  mutation AddParticipant($input: AddParticipantInput!) {
+    addParticipant(input: $input) {
+      id conversationId userId customTitle customAvatar createdAt
+      canAddMembers canRemoveMembers canSendMessages
+    }
+  }
+`;
+var REMOVE_PARTICIPANT = `
+  mutation RemoveParticipant($input: RemoveParticipantInput!) {
+    removeParticipant(input: $input) { success conversationId userId }
+  }
+`;
+var UPDATE_PARTICIPANT_ROLE = `
+  mutation UpdateParticipantRole($input: UpdateParticipantRoleInput!) {
+    updateParticipantRole(input: $input) {
+      id conversationId userId canAddMembers canRemoveMembers canSendMessages
+    }
+  }
+`;
+var LEAVE_CONVERSATION = `
+  mutation LeaveConversation($conversationId: ID!) {
+    leaveConversation(conversationId: $conversationId) { success conversationId }
+  }
+`;
+var ARCHIVE_CONVERSATION = `
+  mutation ArchiveConversation($id: ID!) {
+    archiveConversation(id: $id) { id state }
+  }
+`;
+var UNARCHIVE_CONVERSATION = `
+  mutation UnarchiveConversation($id: ID!) {
+    unarchiveConversation(id: $id) { id state }
+  }
+`;
+var MUTE_CONVERSATION = `
+  mutation MuteConversation($conversationId: ID!, $until: DateTime) {
+    muteConversation(conversationId: $conversationId, until: $until) {
+      id conversationId userId
+    }
+  }
+`;
+var UNMUTE_CONVERSATION = `
+  mutation UnmuteConversation($conversationId: ID!) {
+    unmuteConversation(conversationId: $conversationId) {
+      id conversationId userId
+    }
+  }
+`;
+var PIN_CONVERSATION = `
+  mutation PinConversation($conversationId: ID!) {
+    pinConversation(conversationId: $conversationId) {
+      id conversationId userId
+    }
+  }
+`;
+var UNPIN_CONVERSATION = `
+  mutation UnpinConversation($conversationId: ID!) {
+    unpinConversation(conversationId: $conversationId) {
+      id conversationId userId
+    }
+  }
+`;
+var MARK_CONVERSATION_AS_READ = `
+  mutation MarkConversationAsRead($conversationId: ID!, $messageId: ID) {
+    markConversationAsRead(conversationId: $conversationId, messageId: $messageId) {
+      id conversationId userId
+    }
+  }
+`;
+var CREATE_INVITE_LINK = `
+  mutation CreateInviteLink($input: CreateInviteLinkInput!) {
+    createInviteLink(input: $input) {
+      code url currentUses maxUses expiresAt createdAt
+    }
+  }
+`;
+var JOIN_VIA_INVITE_LINK = `
+  mutation JoinViaInviteLink($code: String!) {
+    joinViaInviteLink(code: $code) {
+      id conversationId userId createdAt
+    }
+  }
+`;
+var VALIDATE_INVITE_LINK = `
+  query ValidateInviteLink($code: String!) {
+    validateInviteLink(code: $code) {
+      valid usesRemaining expiresAt
+      conversation { id title type }
+    }
+  }
+`;
+var VOTE_POLL = `
+  mutation VotePoll($pollId: ID!, $optionIds: [ID!]!) {
+    votePoll(pollId: $pollId, optionIds: $optionIds) {
+      id question totalVotes isClosed
+    }
+  }
+`;
+var UPDATE_NOTIFICATION_SETTINGS = `
+  mutation UpdateNotificationSettings($input: UpdateNotificationSettingsInput!) {
+    updateNotificationSettings(input: $input) {
+      id conversationId userId
+    }
+  }
+`;
 
 // src/modules/conversations/tools.ts
 var ConversationTypeEnum = z.enum(["DIRECT", "GROUP", "CHANNEL"]);
@@ -394,6 +671,903 @@ function registerConversationsTools(server, ctx, track) {
       }
     }
   );
+  registerMessageTools(server, ctx, track);
+  registerDraftTools(server, ctx, track);
+  registerReactionTools(server, ctx, track);
+  registerThreadAndDirectTools(server, ctx, track);
+  registerMentionsAndSearchTools(server, ctx, track);
+  registerPresenceAndTypingTools(server, ctx, track);
+  registerParticipantTools(server, ctx, track);
+  registerConversationActionTools(server, ctx, track);
+  registerInviteTools(server, ctx, track);
+  registerPollAndNotificationTools(server, ctx, track);
+  registerPollingTools(server, ctx, track);
+}
+function unwrap(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+var PresenceStatusEnum = z.enum(["ONLINE", "OFFLINE", "AWAY", "DO_NOT_DISTURB"]);
+var ParticipantRoleEnum = z.enum(["ADMIN", "MODERATOR", "MEMBER", "GUEST"]);
+var NotificationLevelExtEnum = z.enum(["ALL", "MENTIONS", "MUTED", "NONE"]);
+function registerMessageTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "conversations_messages_get")),
+    {
+      title: "Get Message",
+      description: "Fetch a single message by ID.",
+      inputSchema: { id: z.string().describe("Message ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_MESSAGE, {
+          id
+        });
+        if (!data.message) return errorResult(`Message ${id} not found`);
+        return jsonResult(data.message);
+      } catch (error) {
+        ctx.logger.error("conversations_messages_get failed", { error });
+        return errorResult(`Failed to get message: ${unwrap(error)}`);
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "conversations_messages_edit")),
+    {
+      title: "Edit Message",
+      description: "Edit an existing message. Provide new content (object) and optional reason.",
+      inputSchema: {
+        id: z.string().describe("Message ID to edit"),
+        content: z.record(z.unknown()).describe('New message content (e.g. { text: "..." })'),
+        reason: z.string().optional().describe("Optional reason for the edit (audit log)")
+      }
+    },
+    async ({ id, content, reason }) => {
+      try {
+        const input = { id, content };
+        if (reason !== void 0) input.reason = reason;
+        const data = await ctx.gql.workspace.request(EDIT_MESSAGE, {
+          input
+        });
+        return jsonResult(data.editMessage);
+      } catch (error) {
+        ctx.logger.error("conversations_messages_edit failed", { error });
+        return errorResult(`Failed to edit message: ${unwrap(error)}`);
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "conversations_messages_delete")),
+    {
+      title: "Delete Message",
+      description: "Soft-delete (default) or hard-delete a message.",
+      inputSchema: {
+        id: z.string().describe("Message ID to delete"),
+        hard: z.boolean().optional().describe("Hard delete (default: false = soft delete)")
+      }
+    },
+    async ({ id, hard }) => {
+      try {
+        const data = await ctx.gql.workspace.request(DELETE_MESSAGE, { id, hard });
+        return jsonResult(data.deleteMessage);
+      } catch (error) {
+        ctx.logger.error("conversations_messages_delete failed", { error });
+        return errorResult(`Failed to delete message: ${unwrap(error)}`);
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "conversations_messages_forward")),
+    {
+      title: "Forward Message",
+      description: "Forward an existing message into another conversation.",
+      inputSchema: {
+        messageId: z.string().describe("Source message ID"),
+        targetConversationId: z.string().describe("Destination conversation ID")
+      }
+    },
+    async ({ messageId, targetConversationId }) => {
+      try {
+        const data = await ctx.gql.workspace.request(FORWARD_MESSAGE, { messageId, targetConversationId });
+        if (!data.forwardMessage.success || !data.forwardMessage.message) {
+          return errorResult("Forward failed: server returned no message");
+        }
+        return jsonResult(data.forwardMessage.message);
+      } catch (error) {
+        ctx.logger.error("conversations_messages_forward failed", { error });
+        return errorResult(`Failed to forward message: ${unwrap(error)}`);
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "conversations_messages_pin")),
+    {
+      title: "Pin Message",
+      description: "Pin a message to its conversation.",
+      inputSchema: { messageId: z.string().describe("Message ID to pin") }
+    },
+    async ({ messageId }) => {
+      try {
+        const data = await ctx.gql.workspace.request(PIN_MESSAGE, {
+          messageId
+        });
+        return jsonResult(data.pinMessage);
+      } catch (error) {
+        ctx.logger.error("conversations_messages_pin failed", { error });
+        return errorResult(`Failed to pin message: ${unwrap(error)}`);
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "conversations_messages_unpin")),
+    {
+      title: "Unpin Message",
+      description: "Remove a pinned message from its conversation.",
+      inputSchema: { messageId: z.string().describe("Message ID to unpin") }
+    },
+    async ({ messageId }) => {
+      try {
+        const data = await ctx.gql.workspace.request(UNPIN_MESSAGE, {
+          messageId
+        });
+        return jsonResult(data.unpinMessage);
+      } catch (error) {
+        ctx.logger.error("conversations_messages_unpin failed", { error });
+        return errorResult(`Failed to unpin message: ${unwrap(error)}`);
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "conversations_messages_hide")),
+    {
+      title: "Hide Message (moderate)",
+      description: "Moderator action: hide a message with a reason.",
+      inputSchema: {
+        messageId: z.string().describe("Message ID to hide"),
+        reason: z.string().describe("Moderation reason")
+      }
+    },
+    async ({ messageId, reason }) => {
+      try {
+        const data = await ctx.gql.workspace.request(HIDE_MESSAGE, {
+          messageId,
+          reason
+        });
+        return jsonResult(data.hideMessage);
+      } catch (error) {
+        ctx.logger.error("conversations_messages_hide failed", { error });
+        return errorResult(`Failed to hide message: ${unwrap(error)}`);
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "conversations_messages_unhide")),
+    {
+      title: "Unhide Message (moderate)",
+      description: "Moderator action: restore a previously hidden message.",
+      inputSchema: { messageId: z.string().describe("Message ID to unhide") }
+    },
+    async ({ messageId }) => {
+      try {
+        const data = await ctx.gql.workspace.request(
+          UNHIDE_MESSAGE,
+          { messageId }
+        );
+        return jsonResult(data.unhideMessage);
+      } catch (error) {
+        ctx.logger.error("conversations_messages_unhide failed", { error });
+        return errorResult(`Failed to unhide message: ${unwrap(error)}`);
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "conversations_messages_search")),
+    {
+      title: "Search Messages",
+      description: "Full-text search across messages. Optionally scope to a conversation.",
+      inputSchema: {
+        query: z.string().describe("Search query"),
+        conversationId: z.string().optional().describe("Restrict to this conversation"),
+        first: z.number().optional(),
+        after: z.string().optional()
+      }
+    },
+    async ({ query, conversationId, first, after }) => {
+      try {
+        const data = await ctx.gql.workspace.request(SEARCH_MESSAGES, { query, conversationId, first, after });
+        return jsonResult({
+          items: data.searchMessages.edges.map((e) => e.node),
+          pageInfo: data.searchMessages.pageInfo,
+          totalCount: data.searchMessages.totalCount
+        });
+      } catch (error) {
+        ctx.logger.error("conversations_messages_search failed", { error });
+        return errorResult(`Failed to search messages: ${unwrap(error)}`);
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "conversations_messages_unread")),
+    {
+      title: "List Unread Messages",
+      description: "List unread messages for the current actor across all conversations.",
+      inputSchema: { first: z.number().optional(), after: z.string().optional() }
+    },
+    async ({ first, after }) => {
+      try {
+        const data = await ctx.gql.workspace.request(UNREAD_MESSAGES, { first, after });
+        return jsonResult({
+          items: data.unreadMessages.edges.map((e) => e.node),
+          pageInfo: data.unreadMessages.pageInfo,
+          totalCount: data.unreadMessages.totalCount
+        });
+      } catch (error) {
+        ctx.logger.error("conversations_messages_unread failed", { error });
+        return errorResult(`Failed to list unread messages: ${unwrap(error)}`);
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "conversations_messages_report")),
+    {
+      title: "Report Message",
+      description: "Report a message for moderation review.",
+      inputSchema: {
+        messageId: z.string().describe("Message ID to report"),
+        reason: z.string().describe("Reason for the report")
+      }
+    },
+    async ({ messageId, reason }) => {
+      try {
+        const data = await ctx.gql.workspace.request(REPORT_MESSAGE, { messageId, reason });
+        return jsonResult(data.reportMessage);
+      } catch (error) {
+        ctx.logger.error("conversations_messages_report failed", { error });
+        return errorResult(`Failed to report message: ${unwrap(error)}`);
+      }
+    }
+  );
+}
+function registerDraftTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "conversations_drafts_get")),
+    {
+      title: "Get Draft",
+      description: "Fetch the current actor\u2019s draft for a conversation, if any.",
+      inputSchema: { conversationId: z.string().describe("Conversation ID") }
+    },
+    async ({ conversationId }) => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_DRAFT, { conversationId });
+        return jsonResult(data.draft);
+      } catch (error) {
+        ctx.logger.error("conversations_drafts_get failed", { error });
+        return errorResult(`Failed to get draft: ${unwrap(error)}`);
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "conversations_drafts_save")),
+    {
+      title: "Save Draft",
+      description: "Save (upsert) the current actor\u2019s draft for a conversation.",
+      inputSchema: {
+        conversationId: z.string().describe("Conversation ID"),
+        content: z.record(z.unknown()).describe("Draft content payload"),
+        parentMessageId: z.string().optional().describe("Reply parent (for thread drafts)")
+      }
+    },
+    async ({ conversationId, content, parentMessageId }) => {
+      try {
+        const input = { conversationId, content };
+        if (parentMessageId !== void 0) input.parentMessageId = parentMessageId;
+        const data = await ctx.gql.workspace.request(SAVE_DRAFT, { input });
+        return jsonResult(data.saveDraft);
+      } catch (error) {
+        ctx.logger.error("conversations_drafts_save failed", { error });
+        return errorResult(`Failed to save draft: ${unwrap(error)}`);
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "conversations_drafts_delete")),
+    {
+      title: "Delete Draft",
+      description: "Delete the current actor\u2019s draft for a conversation.",
+      inputSchema: { conversationId: z.string().describe("Conversation ID") }
+    },
+    async ({ conversationId }) => {
+      try {
+        const data = await ctx.gql.workspace.request(DELETE_DRAFT, { conversationId });
+        return jsonResult(data.deleteDraft);
+      } catch (error) {
+        ctx.logger.error("conversations_drafts_delete failed", { error });
+        return errorResult(`Failed to delete draft: ${unwrap(error)}`);
+      }
+    }
+  );
+}
+function registerReactionTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "conversations_reactions_add")),
+    {
+      title: "Add Reaction",
+      description: "Add an emoji reaction to a message.",
+      inputSchema: {
+        messageId: z.string().describe("Message ID"),
+        emoji: z.string().describe("Emoji character / shortcode")
+      }
+    },
+    async ({ messageId, emoji }) => {
+      try {
+        const data = await ctx.gql.workspace.request(
+          ADD_REACTION,
+          { messageId, emoji }
+        );
+        return jsonResult(data.addReaction);
+      } catch (error) {
+        ctx.logger.error("conversations_reactions_add failed", { error });
+        return errorResult(`Failed to add reaction: ${unwrap(error)}`);
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "conversations_reactions_remove")),
+    {
+      title: "Remove Reaction",
+      description: "Remove the current actor\u2019s emoji reaction from a message.",
+      inputSchema: {
+        messageId: z.string().describe("Message ID"),
+        emoji: z.string().describe("Emoji character / shortcode")
+      }
+    },
+    async ({ messageId, emoji }) => {
+      try {
+        const data = await ctx.gql.workspace.request(REMOVE_REACTION, { messageId, emoji });
+        return jsonResult(data.removeReaction);
+      } catch (error) {
+        ctx.logger.error("conversations_reactions_remove failed", { error });
+        return errorResult(`Failed to remove reaction: ${unwrap(error)}`);
+      }
+    }
+  );
+}
+function registerThreadAndDirectTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "conversations_threads_get")),
+    {
+      title: "Get Thread",
+      description: "List the replies under a thread-root message.",
+      inputSchema: {
+        messageId: z.string().describe("Thread root message ID"),
+        first: z.number().optional(),
+        after: z.string().optional()
+      }
+    },
+    async ({ messageId, first, after }) => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_THREAD, { messageId, first, after });
+        return jsonResult({
+          items: data.thread.edges.map((e) => e.node),
+          pageInfo: data.thread.pageInfo,
+          totalCount: data.thread.totalCount
+        });
+      } catch (error) {
+        ctx.logger.error("conversations_threads_get failed", { error });
+        return errorResult(`Failed to load thread: ${unwrap(error)}`);
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "conversations_get_or_create_direct")),
+    {
+      title: "Get or Create Direct Conversation",
+      description: "Open (or create) a 1:1 DM conversation with another user.",
+      inputSchema: { userId: z.string().describe("Other user ID") }
+    },
+    async ({ userId }) => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_OR_CREATE_DIRECT_CONVERSATION, { userId });
+        return jsonResult(data.getOrCreateDirectConversation);
+      } catch (error) {
+        ctx.logger.error("conversations_get_or_create_direct failed", { error });
+        return errorResult(`Failed to open direct conversation: ${unwrap(error)}`);
+      }
+    }
+  );
+}
+function registerMentionsAndSearchTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "conversations_mentions_list")),
+    {
+      title: "List Mentions",
+      description: "List messages that mention the current actor.",
+      inputSchema: {
+        first: z.number().optional(),
+        after: z.string().optional(),
+        unreadOnly: z.boolean().optional().describe("Only show unread mentions")
+      }
+    },
+    async ({ first, after, unreadOnly }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_MENTIONS, { first, after, unreadOnly });
+        return jsonResult({
+          items: data.mentions.edges.map((e) => e.node),
+          pageInfo: data.mentions.pageInfo,
+          totalCount: data.mentions.totalCount
+        });
+      } catch (error) {
+        ctx.logger.error("conversations_mentions_list failed", { error });
+        return errorResult(`Failed to list mentions: ${unwrap(error)}`);
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "conversations_search")),
+    {
+      title: "Search Conversations",
+      description: "Full-text search across conversations the actor is a member of.",
+      inputSchema: {
+        query: z.string().describe("Search query"),
+        first: z.number().optional(),
+        after: z.string().optional()
+      }
+    },
+    async ({ query, first, after }) => {
+      try {
+        const data = await ctx.gql.workspace.request(SEARCH_CONVERSATIONS, { query, first, after });
+        return jsonResult({
+          items: data.searchConversations.edges.map((e) => e.node),
+          pageInfo: data.searchConversations.pageInfo,
+          totalCount: data.searchConversations.totalCount
+        });
+      } catch (error) {
+        ctx.logger.error("conversations_search failed", { error });
+        return errorResult(`Failed to search conversations: ${unwrap(error)}`);
+      }
+    }
+  );
+}
+function registerPresenceAndTypingTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "conversations_presence_get")),
+    {
+      title: "Get Presence",
+      description: "Get presence status (online/away/etc) for a set of user IDs.",
+      inputSchema: {
+        userIds: z.array(z.string()).describe("User IDs to look up")
+      }
+    },
+    async ({ userIds }) => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_PRESENCE, { userIds });
+        return jsonResult({ items: data.presence });
+      } catch (error) {
+        ctx.logger.error("conversations_presence_get failed", { error });
+        return errorResult(`Failed to get presence: ${unwrap(error)}`);
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "conversations_presence_update")),
+    {
+      title: "Update Presence",
+      description: "Update the current actor\u2019s presence status and optional custom message.",
+      inputSchema: {
+        status: PresenceStatusEnum,
+        customStatus: z.string().optional()
+      }
+    },
+    async ({ status, customStatus }) => {
+      try {
+        const data = await ctx.gql.workspace.request(UPDATE_PRESENCE, { status, customStatus });
+        return jsonResult(data.updatePresence);
+      } catch (error) {
+        ctx.logger.error("conversations_presence_update failed", { error });
+        return errorResult(`Failed to update presence: ${unwrap(error)}`);
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "conversations_typing_list")),
+    {
+      title: "List Typing Indicators",
+      description: "List users currently typing in a conversation.",
+      inputSchema: { conversationId: z.string() }
+    },
+    async ({ conversationId }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_TYPING_INDICATORS, { conversationId });
+        return jsonResult({ items: data.typingIndicators });
+      } catch (error) {
+        ctx.logger.error("conversations_typing_list failed", { error });
+        return errorResult(`Failed to list typing indicators: ${unwrap(error)}`);
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "conversations_typing_start")),
+    {
+      title: "Start Typing",
+      description: "Broadcast that the current actor started typing in a conversation.",
+      inputSchema: { conversationId: z.string() }
+    },
+    async ({ conversationId }) => {
+      try {
+        const data = await ctx.gql.workspace.request(START_TYPING, {
+          conversationId
+        });
+        return jsonResult({ ok: data.startTyping });
+      } catch (error) {
+        ctx.logger.error("conversations_typing_start failed", { error });
+        return errorResult(`Failed to start typing: ${unwrap(error)}`);
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "conversations_typing_stop")),
+    {
+      title: "Stop Typing",
+      description: "Broadcast that the current actor stopped typing in a conversation.",
+      inputSchema: { conversationId: z.string() }
+    },
+    async ({ conversationId }) => {
+      try {
+        const data = await ctx.gql.workspace.request(STOP_TYPING, {
+          conversationId
+        });
+        return jsonResult({ ok: data.stopTyping });
+      } catch (error) {
+        ctx.logger.error("conversations_typing_stop failed", { error });
+        return errorResult(`Failed to stop typing: ${unwrap(error)}`);
+      }
+    }
+  );
+}
+function registerParticipantTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "conversations_participants_add")),
+    {
+      title: "Add Participant",
+      description: "Add a user to a conversation, optionally with a specific role.",
+      inputSchema: {
+        conversationId: z.string(),
+        userId: z.string(),
+        role: ParticipantRoleEnum.optional()
+      }
+    },
+    async ({ conversationId, userId, role }) => {
+      try {
+        const input = { conversationId, userId };
+        if (role !== void 0) input.role = role;
+        const data = await ctx.gql.workspace.request(ADD_PARTICIPANT, { input });
+        return jsonResult(data.addParticipant);
+      } catch (error) {
+        ctx.logger.error("conversations_participants_add failed", { error });
+        return errorResult(`Failed to add participant: ${unwrap(error)}`);
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "conversations_participants_remove")),
+    {
+      title: "Remove Participant",
+      description: "Remove a user from a conversation.",
+      inputSchema: {
+        conversationId: z.string(),
+        userId: z.string(),
+        reason: z.string().optional()
+      }
+    },
+    async ({ conversationId, userId, reason }) => {
+      try {
+        const input = { conversationId, userId };
+        if (reason !== void 0) input.reason = reason;
+        const data = await ctx.gql.workspace.request(REMOVE_PARTICIPANT, { input });
+        return jsonResult(data.removeParticipant);
+      } catch (error) {
+        ctx.logger.error("conversations_participants_remove failed", { error });
+        return errorResult(`Failed to remove participant: ${unwrap(error)}`);
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "conversations_participants_update_role")),
+    {
+      title: "Update Participant Role",
+      description: "Change a participant\u2019s role in a conversation.",
+      inputSchema: {
+        conversationId: z.string(),
+        userId: z.string(),
+        role: ParticipantRoleEnum
+      }
+    },
+    async ({ conversationId, userId, role }) => {
+      try {
+        const data = await ctx.gql.workspace.request(UPDATE_PARTICIPANT_ROLE, { input: { conversationId, userId, role } });
+        return jsonResult(data.updateParticipantRole);
+      } catch (error) {
+        ctx.logger.error("conversations_participants_update_role failed", { error });
+        return errorResult(`Failed to update participant role: ${unwrap(error)}`);
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "conversations_leave")),
+    {
+      title: "Leave Conversation",
+      description: "Leave a conversation as the current actor.",
+      inputSchema: { conversationId: z.string() }
+    },
+    async ({ conversationId }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LEAVE_CONVERSATION, { conversationId });
+        return jsonResult(data.leaveConversation);
+      } catch (error) {
+        ctx.logger.error("conversations_leave failed", { error });
+        return errorResult(`Failed to leave conversation: ${unwrap(error)}`);
+      }
+    }
+  );
+}
+function registerConversationActionTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "conversations_archive")),
+    {
+      title: "Archive Conversation",
+      description: "Archive a conversation (state \u2192 ARCHIVED).",
+      inputSchema: { id: z.string().describe("Conversation ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(ARCHIVE_CONVERSATION, { id });
+        return jsonResult(data.archiveConversation);
+      } catch (error) {
+        ctx.logger.error("conversations_archive failed", { error });
+        return errorResult(`Failed to archive: ${unwrap(error)}`);
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "conversations_unarchive")),
+    {
+      title: "Unarchive Conversation",
+      description: "Restore an archived conversation.",
+      inputSchema: { id: z.string().describe("Conversation ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(UNARCHIVE_CONVERSATION, { id });
+        return jsonResult(data.unarchiveConversation);
+      } catch (error) {
+        ctx.logger.error("conversations_unarchive failed", { error });
+        return errorResult(`Failed to unarchive: ${unwrap(error)}`);
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "conversations_mute")),
+    {
+      title: "Mute Conversation",
+      description: "Mute notifications for a conversation. Optional `until` (ISO timestamp).",
+      inputSchema: {
+        conversationId: z.string(),
+        until: z.string().optional().describe("ISO timestamp; omit for indefinite mute")
+      }
+    },
+    async ({ conversationId, until }) => {
+      try {
+        const data = await ctx.gql.workspace.request(MUTE_CONVERSATION, { conversationId, until });
+        return jsonResult(data.muteConversation);
+      } catch (error) {
+        ctx.logger.error("conversations_mute failed", { error });
+        return errorResult(`Failed to mute: ${unwrap(error)}`);
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "conversations_unmute")),
+    {
+      title: "Unmute Conversation",
+      description: "Re-enable notifications for a conversation.",
+      inputSchema: { conversationId: z.string().describe("Conversation ID") }
+    },
+    async ({ conversationId }) => {
+      try {
+        const data = await ctx.gql.workspace.request(UNMUTE_CONVERSATION, { conversationId });
+        return jsonResult(data.unmuteConversation);
+      } catch (error) {
+        ctx.logger.error("conversations_unmute failed", { error });
+        return errorResult(`Failed to unmute: ${unwrap(error)}`);
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "conversations_pin")),
+    {
+      title: "Pin Conversation",
+      description: "Pin a conversation to the top of the actor\u2019s list.",
+      inputSchema: { conversationId: z.string().describe("Conversation ID") }
+    },
+    async ({ conversationId }) => {
+      try {
+        const data = await ctx.gql.workspace.request(PIN_CONVERSATION, { conversationId });
+        return jsonResult(data.pinConversation);
+      } catch (error) {
+        ctx.logger.error("conversations_pin failed", { error });
+        return errorResult(`Failed to pin: ${unwrap(error)}`);
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "conversations_unpin")),
+    {
+      title: "Unpin Conversation",
+      description: "Unpin a conversation from the actor\u2019s list.",
+      inputSchema: { conversationId: z.string().describe("Conversation ID") }
+    },
+    async ({ conversationId }) => {
+      try {
+        const data = await ctx.gql.workspace.request(UNPIN_CONVERSATION, { conversationId });
+        return jsonResult(data.unpinConversation);
+      } catch (error) {
+        ctx.logger.error("conversations_unpin failed", { error });
+        return errorResult(`Failed to unpin: ${unwrap(error)}`);
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "conversations_mark_as_read")),
+    {
+      title: "Mark Conversation As Read",
+      description: "Mark a conversation as read up to a specific message (defaults to latest).",
+      inputSchema: {
+        conversationId: z.string(),
+        messageId: z.string().optional()
+      }
+    },
+    async ({ conversationId, messageId }) => {
+      try {
+        const data = await ctx.gql.workspace.request(MARK_CONVERSATION_AS_READ, { conversationId, messageId });
+        return jsonResult(data.markConversationAsRead);
+      } catch (error) {
+        ctx.logger.error("conversations_mark_as_read failed", { error });
+        return errorResult(`Failed to mark as read: ${unwrap(error)}`);
+      }
+    }
+  );
+}
+function registerInviteTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "conversations_invites_create")),
+    {
+      title: "Create Invite Link",
+      description: "Mint a shareable invite link/code for a conversation.",
+      inputSchema: {
+        conversationId: z.string(),
+        maxUses: z.number().int().optional(),
+        expiresAt: z.string().optional().describe("ISO timestamp")
+      }
+    },
+    async ({ conversationId, maxUses, expiresAt }) => {
+      try {
+        const input = { conversationId };
+        if (maxUses !== void 0) input.maxUses = maxUses;
+        if (expiresAt !== void 0) input.expiresAt = expiresAt;
+        const data = await ctx.gql.workspace.request(CREATE_INVITE_LINK, { input });
+        return jsonResult(data.createInviteLink);
+      } catch (error) {
+        ctx.logger.error("conversations_invites_create failed", { error });
+        return errorResult(`Failed to create invite link: ${unwrap(error)}`);
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "conversations_invites_join")),
+    {
+      title: "Join Via Invite Link",
+      description: "Redeem an invite code/link and join the conversation.",
+      inputSchema: { code: z.string().describe("Invite code") }
+    },
+    async ({ code }) => {
+      try {
+        const data = await ctx.gql.workspace.request(JOIN_VIA_INVITE_LINK, { code });
+        return jsonResult(data.joinViaInviteLink);
+      } catch (error) {
+        ctx.logger.error("conversations_invites_join failed", { error });
+        return errorResult(`Failed to join via invite link: ${unwrap(error)}`);
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "conversations_invites_validate")),
+    {
+      title: "Validate Invite Link",
+      description: "Check whether an invite code is currently valid; returns conversation preview.",
+      inputSchema: { code: z.string().describe("Invite code") }
+    },
+    async ({ code }) => {
+      try {
+        const data = await ctx.gql.workspace.request(VALIDATE_INVITE_LINK, { code });
+        return jsonResult(data.validateInviteLink);
+      } catch (error) {
+        ctx.logger.error("conversations_invites_validate failed", { error });
+        return errorResult(`Failed to validate invite link: ${unwrap(error)}`);
+      }
+    }
+  );
+}
+function registerPollAndNotificationTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "conversations_polls_vote")),
+    {
+      title: "Vote in Poll",
+      description: "Cast a vote (one or more options) on a poll attached to a message.",
+      inputSchema: {
+        pollId: z.string(),
+        optionIds: z.array(z.string()).describe("Option IDs to vote for")
+      }
+    },
+    async ({ pollId, optionIds }) => {
+      try {
+        const data = await ctx.gql.workspace.request(
+          VOTE_POLL,
+          { pollId, optionIds }
+        );
+        return jsonResult(data.votePoll);
+      } catch (error) {
+        ctx.logger.error("conversations_polls_vote failed", { error });
+        return errorResult(`Failed to vote: ${unwrap(error)}`);
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "conversations_notifications_update")),
+    {
+      title: "Update Notification Settings",
+      description: "Update notification level (ALL | MENTIONS | MUTED | NONE) for a conversation membership.",
+      inputSchema: {
+        conversationId: z.string(),
+        notificationLevel: NotificationLevelExtEnum
+      }
+    },
+    async ({ conversationId, notificationLevel }) => {
+      try {
+        const data = await ctx.gql.workspace.request(UPDATE_NOTIFICATION_SETTINGS, {
+          input: { conversationId, notificationLevel }
+        });
+        return jsonResult(data.updateNotificationSettings);
+      } catch (error) {
+        ctx.logger.error("conversations_notifications_update failed", { error });
+        return errorResult(`Failed to update notification settings: ${unwrap(error)}`);
+      }
+    }
+  );
+}
+function registerPollingTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "conversations_messages_check")),
+    {
+      title: "Check for New Messages (poll)",
+      description: "Polling substitute for the messageAdded / messageUpdated / messageDeleted subscriptions. Returns recent messages in a conversation; clients should call repeatedly with the last seen cursor.",
+      inputSchema: {
+        conversationId: z.string().describe("Conversation ID"),
+        first: z.number().optional().describe("Page size (default 20)"),
+        after: z.string().optional().describe("Cursor from the previous poll")
+      }
+    },
+    async ({ conversationId, first, after }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_MESSAGES, { conversationId, first: first ?? 20, after });
+        return jsonResult({
+          items: data.messages.edges.map((e) => e.node),
+          pageInfo: data.messages.pageInfo
+        });
+      } catch (error) {
+        ctx.logger.error("conversations_messages_check failed", { error });
+        return errorResult(`Failed to poll messages: ${unwrap(error)}`);
+      }
+    }
+  );
 }
 
 // src/modules/conversations/index.ts