universal-mcp-applications 0.1.33__py3-none-any.whl → 0.1.39rc16__py3-none-any.whl

universal_mcp/applications/ms_teams/app.py

@@ -1,5 +1,4 @@
-from typing import Any
-
+from typing import Any, Literal
 from universal_mcp.applications.application import APIApplication
 from universal_mcp.integrations import Integration
 
@@ -9,101 +8,63 @@ class MsTeamsApp(APIApplication):
         super().__init__(name="ms_teams", integration=integration, **kwargs)
         self.base_url = "https://graph.microsoft.com/v1.0"
 
-    def get_user_chats(
+    async def get_me(
         self,
-        top: int | None = None,
-        skip: int | None = None,
-        search: str | None = None,
-        filter: str | None = None,
-        count: bool | None = None,
-        orderby: list[str] | None = None,
         select: list[str] | None = None,
         expand: list[str] | None = None,
     ) -> dict[str, Any]:
         """
-        Retrieves a collection of chats the authenticated user is participating in. Supports optional OData query parameters for advanced filtering, sorting, pagination, and field selection, enabling customized data retrieval from the Microsoft Graph API.
+        Get the currently signed-in user.
 
         Args:
-            top (integer): Show only the first n items Example: '50'.
-            skip (integer): Skip the first n items
-            search (string): Search items by search phrases
-            filter (string): Filter items by property values
-            count (boolean): Include count of items
-            orderby (array): Order items by property values
-            select (array): Select properties to be returned
-            expand (array): Expand related entities
+            select (array): Select specific properties to return.
+            expand (array): Expand related entities.
 
         Returns:
-            dict[str, Any]: Retrieved collection
+            dict[str, Any]: The user resource.
 
         Raises:
-            HTTPStatusError: Raised when the API request fails with detailed error information including status code and response body.
+            HTTPStatusError: If the API request fails.
 
         Tags:
-            chats.chat, important
+            user, me, read, profile
         """
-        url = f"{self.base_url}/chats"
+        url = f"{self.base_url}/me"
+
+        # Helper to format list params
+        def fmt(val):
+            return ",".join(val) if isinstance(val, list) else val
+
         query_params = {
-            k: v
+            k: fmt(v)
             for k, v in [
-                ("$top", top),
-                ("$skip", skip),
-                ("$search", search),
-                ("$filter", filter),
-                ("$count", count),
-                ("$orderby", orderby),
                 ("$select", select),
                 ("$expand", expand),
             ]
             if v is not None
         }
-        response = self._get(url, params=query_params)
-        return self._handle_response(response)
-
-    def get_joined_teams(self) -> list[dict[str, Any]]:
-        """
-        Fetches all Microsoft Teams the authenticated user belongs to by querying the `/me/joinedTeams` Graph API endpoint. It returns a list of dictionaries, where each dictionary represents a single team's details, unlike functions that list channels or chats for a specific team.
 
-        Returns:
-            A list of dictionaries, where each dictionary represents a team.
+        response = await self._aget(url, params=query_params)
+        return self._handle_response(response)
 
-        Raises:
-            httpx.HTTPStatusError: If the API request fails due to authentication or other issues.
 
-        Tags:
-            read, list, teams, microsoft-teams, api, important
-        """
-        url = f"{self.base_url}/me/joinedTeams"
-        response = self._get(url)
-        data = self._handle_response(response)
-        # The API returns the list of teams under the "value" key.
-        return data.get("value", [])
+# Chat Management
 
-    def list_channels_for_team(
+    async def get_user_chats(
         self,
-        team_id: str,
         top: int | None = None,
-        skip: int | None = None,
-        search: str | None = None,
+        expand: list[Literal["members", "lastMessagePreview"]] | None = None,
         filter: str | None = None,
-        count: bool | None = None,
-        orderby: list[str] | None = None,
-        select: list[str] | None = None,
-        expand: list[str] | None = None,
+        orderby: Literal["lastMessagePreview/createdDateTime desc"] | None = None,
     ) -> dict[str, Any]:
         """
-        Retrieves the collection of channels for a specified Microsoft Teams team by its ID. It supports advanced OData query parameters for filtering, sorting, and pagination, distinguishing it from functions that fetch single channels like `get_channel_details`.
+        Retrieves a collection of chats the authenticated user is participating in. Supports optional OData query parameters for advanced filtering, sorting, pagination, and field selection, enabling customized data retrieval from the Microsoft Graph API.
 
         Args:
-            team_id (string): team-id
-            top (integer): Show only the first n items Example: '50'.
-            skip (integer): Skip the first n items
-            search (string): Search items by search phrases
-            filter (string): Filter items by property values
-            count (boolean): Include count of items
-            orderby (array): Order items by property values
-            select (array): Select properties to be returned
-            expand (array): Expand related entities
+            top (integer): Controls the number of items per response. Maximum allowed $top value is 50.
+            expand (array): Currently supports 'members' and 'lastMessagePreview' properties.
+            filter (string): Filters results.
+            orderby (string): Currently supports 'lastMessagePreview/createdDateTime desc'. Ascending order is currently not supported.
 
         Returns:
             dict[str, Any]: Retrieved collection
@@ -112,198 +73,70 @@ class MsTeamsApp(APIApplication):
             HTTPStatusError: Raised when the API request fails with detailed error information including status code and response body.
 
         Tags:
-            teams.channel, important
+            chats.chat, important
         """
-        if team_id is None:
-            raise ValueError("Missing required parameter 'team-id'.")
-        url = f"{self.base_url}/teams/{team_id}/channels"
+        url = f"{self.base_url}/chats"
+        # Helper to format list params
+        def fmt(val):
+            return ",".join(val) if isinstance(val, list) else val
+
         query_params = {
-            k: v
+            k: fmt(v)
             for k, v in [
                 ("$top", top),
-                ("$skip", skip),
-                ("$search", search),
+                ("$expand", expand),
                 ("$filter", filter),
-                ("$count", count),
                 ("$orderby", orderby),
-                ("$select", select),
-                ("$expand", expand),
             ]
             if v is not None
         }
-        response = self._get(url, params=query_params)
+        response = await self._aget(url, params=query_params)
         return self._handle_response(response)
 
-    def send_chat_message(self, chat_id: str, content: str) -> dict[str, Any]:
-        """
-        Posts a new message to a specific Microsoft Teams chat using its unique ID. This function targets direct or group chats, distinguishing it from `send_channel_message`, which posts to public team channels, and `reply_to_chat_message`, which responds to existing messages.
-
-        Args:
-            chat_id: The unique identifier of the chat.
-            content: The message content to send (can be plain text or HTML).
-
-        Returns:
-            A dictionary containing the API response for the sent message, including its ID.
-
-        Raises:
-            httpx.HTTPStatusError: If the API request fails due to invalid ID, permissions, etc.
-
-        Tags:
-            create, send, message, chat, microsoft-teams, api, important
-        """
-        url = f"{self.base_url}/chats/{chat_id}/messages"
-        payload = {"body": {"content": content}}
-        response = self._post(url, data=payload)
-        return self._handle_response(response)
-
-    def send_channel_message(
-        self, team_id: str, channel_id: str, content: str
-    ) -> dict[str, Any]:
-        """
-        Posts a new message to a specified team channel, initiating a new conversation thread. Unlike `reply_to_channel_message`, which replies to a message, this function starts a new topic. It's distinct from `send_chat_message`, which is for private or group chats, not team channels.
-
-        Args:
-            team_id: The unique identifier of the team.
-            channel_id: The unique identifier of the channel within the team.
-            content: The message content to send (can be plain text or HTML).
-
-        Returns:
-            A dictionary containing the API response for the sent message, including its ID.
-
-        Raises:
-            httpx.HTTPStatusError: If the API request fails due to invalid IDs, permissions, etc.
-
-        Tags:
-            create, send, message, channel, microsoft-teams, api, important
-        """
-        url = f"{self.base_url}/teams/{team_id}/channels/{channel_id}/messages"
-        payload = {"body": {"content": content}}
-        response = self._post(url, data=payload)
-        return self._handle_response(response)
-
-    def reply_to_channel_message(
-        self, team_id: str, channel_id: str, message_id: str, content: str
-    ) -> dict[str, Any]:
-        """
-        Posts a reply to a specific message within a Microsoft Teams channel. It uses the team, channel, and original message IDs to target an existing conversation thread, distinguishing it from `send_channel_message` which starts a new one.
-
-        Args:
-            team_id: The unique identifier of the team.
-            channel_id: The unique identifier of the channel.
-            message_id: The unique identifier of the message to reply to.
-            content: The reply message content (can be plain text or HTML).
-
-        Returns:
-            A dictionary containing the API response for the sent reply, including its ID.
-
-        Raises:
-            httpx.HTTPStatusError: If the API request fails due to invalid IDs, permissions, etc.
-
-        Tags:
-            create, send, reply, message, channel, microsoft-teams, api, important
-        """
-        url = f"{self.base_url}/teams/{team_id}/channels/{channel_id}/messages/{message_id}/replies"
-        payload = {"body": {"content": content}}
-        response = self._post(url, data=payload)
-        return self._handle_response(response)
-
-    def create_chat(
+    async def create_chat(
         self,
-        id: str | None = None,
-        chatType: str | None = None,
-        createdDateTime: str | None = None,
-        isHiddenForAllMembers: bool | None = None,
-        lastUpdatedDateTime: str | None = None,
-        onlineMeetingInfo: dict[str, dict[str, Any]] | None = None,
-        tenantId: str | None = None,
+        chatType: Literal["oneOnOne", "group"] | str,
+        members: list[dict[str, Any]],
         topic: str | None = None,
-        viewpoint: dict[str, dict[str, Any]] | None = None,
-        webUrl: str | None = None,
-        installedApps: list[Any] | None = None,
-        lastMessagePreview: Any | None = None,
-        members: list[Any] | None = None,
-        messages: list[Any] | None = None,
-        permissionGrants: list[Any] | None = None,
-        pinnedMessages: list[Any] | None = None,
-        tabs: list[Any] | None = None,
-    ) -> Any:
+    ) -> dict[str, Any]:
         """
-        Creates a new one-on-one or group chat in Microsoft Teams. This function provisions a new conversation using optional parameters like chatType and members, distinguishing it from functions that create teams (`create_team`) or send messages to existing chats (`send_chat_message`).
+        Creates a new one-on-one or group chat in Microsoft Teams. This function provisions a new conversation using required parameters like chatType and members.
 
         Args:
-            id (string): The unique identifier for an entity. Read-only.
-            chatType (string): chatType
-            createdDateTime (string): Date and time at which the chat was created. Read-only.
-            isHiddenForAllMembers (boolean): Indicates whether the chat is hidden for all its members. Read-only.
-            lastUpdatedDateTime (string): Date and time at which the chat was renamed or the list of members was last changed. Read-only.
-            onlineMeetingInfo (object): onlineMeetingInfo
-            tenantId (string): The identifier of the tenant in which the chat was created. Read-only.
+            chatType (string): The type of chat. Possible values are: oneOnOne, group.
+            members (array): A collection of member dictionaries. For oneOnOne chats, typically 2 users. For group chats, multiple users. Each member should specify roles and user binding (e.g. `{'@odata.type': '#microsoft.graph.aadUserConversationMember', 'roles': ['owner'], 'user@odata.bind': 'https://graph.microsoft.com/v1.0/users(\\'<user-id>\\')'}`).
             topic (string): (Optional) Subject or topic for the chat. Only available for group chats.
-            viewpoint (object): viewpoint
-            webUrl (string): The URL for the chat in Microsoft Teams. The URL should be treated as an opaque blob, and not parsed. Read-only.
-            installedApps (array): A collection of all the apps in the chat. Nullable.
-            lastMessagePreview (string): lastMessagePreview
-            members (array): A collection of all the members in the chat. Nullable.
-            messages (array): A collection of all the messages in the chat. Nullable.
-            permissionGrants (array): A collection of permissions granted to apps for the chat.
-            pinnedMessages (array): A collection of all the pinned messages in the chat. Nullable.
-            tabs (array): A collection of all the tabs in the chat. Nullable.
 
         Returns:
-            Any: Created entity
+            dict[str, Any]: The newly created chat entity.
 
         Raises:
             HTTPStatusError: Raised when the API request fails with detailed error information including status code and response body.
 
         Tags:
-            chats.chat
+            chats.chat, create
         """
-        request_body_data = None
         request_body_data = {
-            "id": id,
             "chatType": chatType,
-            "createdDateTime": createdDateTime,
-            "isHiddenForAllMembers": isHiddenForAllMembers,
-            "lastUpdatedDateTime": lastUpdatedDateTime,
-            "onlineMeetingInfo": onlineMeetingInfo,
-            "tenantId": tenantId,
-            "topic": topic,
-            "viewpoint": viewpoint,
-            "webUrl": webUrl,
-            "installedApps": installedApps,
-            "lastMessagePreview": lastMessagePreview,
             "members": members,
-            "messages": messages,
-            "permissionGrants": permissionGrants,
-            "pinnedMessages": pinnedMessages,
-            "tabs": tabs,
-        }
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
+            "topic": topic,
         }
+        # Filter explicitly None values, though for required ones they should be validated by type hints/caller
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
+        
         url = f"{self.base_url}/chats"
-        query_params = {}
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
+        response = await self._apost(url, data=request_body_data, content_type="application/json")
         return self._handle_response(response)
 
-    def get_chat_details(
+    async def get_chat_details(
         self,
         chat_id: str,
-        select: list[str] | None = None,
-        expand: list[str] | None = None,
     ) -> Any:
         """
-        Retrieves the properties and relationships of a specific chat conversation by its unique ID. Unlike `get_user_chats` which lists all chats, this targets one chat. Optional parameters can select specific fields or expand related entities like members or apps to customize the returned data.
+        Retrieves the properties and relationships of a specific chat conversation by its unique ID.
 
         Args:
-            chat_id (string): chat-id
-            select (array): Select properties to be returned
-            expand (array): Expand related entities
+            chat_id (string): The unique identifier of the chat.
 
         Returns:
             Any: Retrieved entity
@@ -312,1512 +145,692 @@ class MsTeamsApp(APIApplication):
             HTTPStatusError: Raised when the API request fails with detailed error information including status code and response body.
 
         Tags:
-            chats.chat
+            chats.chat, read
         """
         if chat_id is None:
             raise ValueError("Missing required parameter 'chat-id'.")
         url = f"{self.base_url}/chats/{chat_id}"
-        query_params = {
-            k: v for k, v in [("$select", select), ("$expand", expand)] if v is not None
-        }
-        response = self._get(url, params=query_params)
+        response = await self._aget(url)
         return self._handle_response(response)
 
-    def update_chat_details(
+    async def update_chat_details(
         self,
         chat_id: str,
-        id: str | None = None,
-        chatType: str | None = None,
-        createdDateTime: str | None = None,
-        isHiddenForAllMembers: bool | None = None,
-        lastUpdatedDateTime: str | None = None,
-        onlineMeetingInfo: dict[str, dict[str, Any]] | None = None,
-        tenantId: str | None = None,
         topic: str | None = None,
-        viewpoint: dict[str, dict[str, Any]] | None = None,
-        webUrl: str | None = None,
-        installedApps: list[Any] | None = None,
-        lastMessagePreview: Any | None = None,
-        members: list[Any] | None = None,
-        messages: list[Any] | None = None,
-        permissionGrants: list[Any] | None = None,
-        pinnedMessages: list[Any] | None = None,
-        tabs: list[Any] | None = None,
     ) -> Any:
         """
-        Updates properties of a specific chat, such as its topic, using its unique ID. This function performs a partial update (PATCH), distinguishing it from `get_chat_details` which only retrieves data, and `create_chat` which creates an entirely new chat conversation.
+        Updates properties of a specific chat, such as its topic, using its unique ID. This function performs a partial update (PATCH). Currently, only the 'topic' property can be updated for group chats.
 
         Args:
-            chat_id (string): chat-id
-            id (string): The unique identifier for an entity. Read-only.
-            chatType (string): chatType
-            createdDateTime (string): Date and time at which the chat was created. Read-only.
-            isHiddenForAllMembers (boolean): Indicates whether the chat is hidden for all its members. Read-only.
-            lastUpdatedDateTime (string): Date and time at which the chat was renamed or the list of members was last changed. Read-only.
-            onlineMeetingInfo (object): onlineMeetingInfo
-            tenantId (string): The identifier of the tenant in which the chat was created. Read-only.
-            topic (string): (Optional) Subject or topic for the chat. Only available for group chats.
-            viewpoint (object): viewpoint
-            webUrl (string): The URL for the chat in Microsoft Teams. The URL should be treated as an opaque blob, and not parsed. Read-only.
-            installedApps (array): A collection of all the apps in the chat. Nullable.
-            lastMessagePreview (string): lastMessagePreview
-            members (array): A collection of all the members in the chat. Nullable.
-            messages (array): A collection of all the messages in the chat. Nullable.
-            permissionGrants (array): A collection of permissions granted to apps for the chat.
-            pinnedMessages (array): A collection of all the pinned messages in the chat. Nullable.
-            tabs (array): A collection of all the tabs in the chat. Nullable.
+            chat_id (string): The unique identifier of the chat.
+            topic (string): (Optional) The new subject or topic for the chat. Only applicable for group chats.
 
         Returns:
-            Any: Success
+            Any: Variable response depending on the API, typically the updated entity or status.
 
         Raises:
             HTTPStatusError: Raised when the API request fails with detailed error information including status code and response body.
 
         Tags:
-            chats.chat
+            chats.chat, update
         """
         if chat_id is None:
             raise ValueError("Missing required parameter 'chat-id'.")
-        request_body_data = None
-        request_body_data = {
-            "id": id,
-            "chatType": chatType,
-            "createdDateTime": createdDateTime,
-            "isHiddenForAllMembers": isHiddenForAllMembers,
-            "lastUpdatedDateTime": lastUpdatedDateTime,
-            "onlineMeetingInfo": onlineMeetingInfo,
-            "tenantId": tenantId,
-            "topic": topic,
-            "viewpoint": viewpoint,
-            "webUrl": webUrl,
-            "installedApps": installedApps,
-            "lastMessagePreview": lastMessagePreview,
-            "members": members,
-            "messages": messages,
-            "permissionGrants": permissionGrants,
-            "pinnedMessages": pinnedMessages,
-            "tabs": tabs,
-        }
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
-        url = f"{self.base_url}/chats/{chat_id}"
-        query_params = {}
-        response = self._patch(url, data=request_body_data, params=query_params)
-        return self._handle_response(response)
-
-    def list_installed_chat_apps(
-        self,
-        chat_id: str,
-        top: int | None = None,
-        skip: int | None = None,
-        search: str | None = None,
-        filter: str | None = None,
-        count: bool | None = None,
-        orderby: list[str] | None = None,
-        select: list[str] | None = None,
-        expand: list[str] | None = None,
-    ) -> dict[str, Any]:
-        """
-        Retrieves applications installed in a specific chat, identified by `chat_id`. Differentiating from `list_user_installed_apps`, which targets a user's personal scope, this function queries a single conversation. It supports optional parameters for advanced filtering, sorting, and pagination to customize the returned collection.
-
-        Args:
-            chat_id (string): chat-id
-            top (integer): Show only the first n items Example: '50'.
-            skip (integer): Skip the first n items
-            search (string): Search items by search phrases
-            filter (string): Filter items by property values
-            count (boolean): Include count of items
-            orderby (array): Order items by property values
-            select (array): Select properties to be returned
-            expand (array): Expand related entities
-
-        Returns:
-            dict[str, Any]: Retrieved collection
-
-        Raises:
-            HTTPStatusError: Raised when the API request fails with detailed error information including status code and response body.
-
-        Tags:
-            chats.teamsAppInstallation
-        """
-        if chat_id is None:
-            raise ValueError("Missing required parameter 'chat-id'.")
-        url = f"{self.base_url}/chats/{chat_id}/installedApps"
-        query_params = {
-            k: v
-            for k, v in [
-                ("$top", top),
-                ("$skip", skip),
-                ("$search", search),
-                ("$filter", filter),
-                ("$count", count),
-                ("$orderby", orderby),
-                ("$select", select),
-                ("$expand", expand),
-            ]
-            if v is not None
-        }
-        response = self._get(url, params=query_params)
-        return self._handle_response(response)
+        
+        request_body_data = {"topic": topic}
+        # Filter explicitly None values
+        request_body_data = {k: v for k, v in request_body_data.items() if v is not None}
+        
+        if not request_body_data:
+             raise ValueError("No updateable parameters provided.")
 
-    def list_chat_members(
-        self,
-        chat_id: str,
-        top: int | None = None,
-        skip: int | None = None,
-        search: str | None = None,
-        filter: str | None = None,
-        count: bool | None = None,
-        orderby: list[str] | None = None,
-        select: list[str] | None = None,
-        expand: list[str] | None = None,
-    ) -> dict[str, Any]:
-        """
-        Retrieves a collection of all members in a specific chat using its ID. It supports OData query parameters for pagination, filtering, and sorting. Unlike `get_chat_member`, which fetches a single individual, this function returns the entire collection of members for the specified chat.
-
-        Args:
-            chat_id (string): chat-id
-            top (integer): Show only the first n items Example: '50'.
-            skip (integer): Skip the first n items
-            search (string): Search items by search phrases
-            filter (string): Filter items by property values
-            count (boolean): Include count of items
-            orderby (array): Order items by property values
-            select (array): Select properties to be returned
-            expand (array): Expand related entities
-
-        Returns:
-            dict[str, Any]: Retrieved collection
-
-        Raises:
-            HTTPStatusError: Raised when the API request fails with detailed error information including status code and response body.
-
-        Tags:
-            chats.conversationMember
-        """
-        if chat_id is None:
-            raise ValueError("Missing required parameter 'chat-id'.")
-        url = f"{self.base_url}/chats/{chat_id}/members"
-        query_params = {
-            k: v
-            for k, v in [
-                ("$top", top),
-                ("$skip", skip),
-                ("$search", search),
-                ("$filter", filter),
-                ("$count", count),
-                ("$orderby", orderby),
-                ("$select", select),
-                ("$expand", expand),
-            ]
-            if v is not None
-        }
-        response = self._get(url, params=query_params)
+        url = f"{self.base_url}/chats/{chat_id}"
+        response = await self._apatch(url, data=request_body_data, content_type="application/json")
         return self._handle_response(response)
 
-    def add_member_to_chat(
+    async def list_chat_members(
         self,
         chat_id: str,
-        id: str | None = None,
-        displayName: str | None = None,
-        roles: list[str] | None = None,
-        visibleHistoryStartDateTime: str | None = None,
-    ) -> Any:
+    ) -> list[dict[str, Any]]:
         """
-        Adds a new member to a specific Microsoft Teams chat using its `chat_id`. This function allows for configuring member roles and chat history visibility. It is the direct counterpart to `delete_chat_member`, performing the 'create' action for a chat's membership.
+        Retrieves a collection of all members in a specific chat using its ID.
+        Note: The Microsoft Graph API for getting chat members does NOT support OData query parameters like $top, $filter, etc.
 
         Args:
-            chat_id (string): chat-id
-            id (string): The unique identifier for an entity. Read-only.
-            displayName (string): The display name of the user.
-            roles (array): The roles for that user. This property contains more qualifiers only when relevant - for example, if the member has owner privileges, the roles property contains owner as one of the values. Similarly, if the member is an in-tenant guest, the roles property contains guest as one of the values. A basic member shouldn't have any values specified in the roles property. An Out-of-tenant external member is assigned the owner role.
-            visibleHistoryStartDateTime (string): The timestamp denoting how far back a conversation's history is shared with the conversation member. This property is settable only for members of a chat.
+            chat_id (string): The unique identifier of the chat.
 
         Returns:
-            Any: Created navigation property.
+            list[dict[str, Any]]: A list of conversationMember objects.
 
         Raises:
             HTTPStatusError: Raised when the API request fails with detailed error information including status code and response body.
 
         Tags:
-            chats.conversationMember
+            chats.conversationMember, list, read
         """
         if chat_id is None:
             raise ValueError("Missing required parameter 'chat-id'.")
-        request_body_data = None
-        request_body_data = {
-            "id": id,
-            "displayName": displayName,
-            "roles": roles,
-            "visibleHistoryStartDateTime": visibleHistoryStartDateTime,
-        }
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
         url = f"{self.base_url}/chats/{chat_id}/members"
-        query_params = {}
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
-        return self._handle_response(response)
+        
+        # This endpoint generally does not support OData params, so we send none.
+        response = await self._aget(url)
+        data = self._handle_response(response)
+        return data.get("value", [])
 
-    def get_chat_member(
-        self,
-        chat_id: str,
-        conversationMember_id: str,
-        select: list[str] | None = None,
-        expand: list[str] | None = None,
+    async def get_chat_member(
+        self, chat_id: str, conversationMember_id: str
     ) -> Any:
         """
-        Retrieves detailed information for a specific member within a chat using their unique ID. This function targets a single individual, distinguishing it from `list_chat_members` which returns all members. The response can be customized by selecting specific properties or expanding related entities.
+        Retrieves detailed information for a specific member within a chat using their unique ID.
+        Note: The Microsoft Graph API for this endpoint does NOT support OData query parameters.
 
         Args:
-            chat_id (string): chat-id
-            conversationMember_id (string): conversationMember-id
-            select (array): Select properties to be returned
-            expand (array): Expand related entities
+            chat_id (string): The unique identifier of the chat.
+            conversationMember_id (string): The unique identifier of the member.
 
         Returns:
-            Any: Retrieved navigation property
+            Any: Retrieved conversationMember entity.
 
         Raises:
             HTTPStatusError: Raised when the API request fails with detailed error information including status code and response body.
 
         Tags:
-            chats.conversationMember
+            chats.conversationMember, read
         """
         if chat_id is None:
             raise ValueError("Missing required parameter 'chat-id'.")
         if conversationMember_id is None:
             raise ValueError("Missing required parameter 'conversationMember-id'.")
         url = f"{self.base_url}/chats/{chat_id}/members/{conversationMember_id}"
-        query_params = {
-            k: v for k, v in [("$select", select), ("$expand", expand)] if v is not None
-        }
-        response = self._get(url, params=query_params)
+        
+        # This endpoint generally does not support OData params
+        response = await self._aget(url)
         return self._handle_response(response)
 
-    def delete_chat_member(self, chat_id: str, conversationMember_id: str) -> Any:
-        """
-        Removes a specific member from a chat using their unique ID and the chat's ID. This function sends a DELETE request to the Microsoft Graph API to permanently remove the user from the conversation, acting as the counterpart to `add_member_to_chat`.
-
-        Args:
-            chat_id (string): chat-id
-            conversationMember_id (string): conversationMember-id
-
-        Returns:
-            Any: Success
+# Chat Messages
 
-        Raises:
-            HTTPStatusError: Raised when the API request fails with detailed error information including status code and response body.
-
-        Tags:
-            chats.conversationMember
-        """
-        if chat_id is None:
-            raise ValueError("Missing required parameter 'chat-id'.")
-        if conversationMember_id is None:
-            raise ValueError("Missing required parameter 'conversationMember-id'.")
-        url = f"{self.base_url}/chats/{chat_id}/members/{conversationMember_id}"
-        query_params = {}
-        response = self._delete(url, params=query_params)
-        return self._handle_response(response)
-
-    def list_chat_messages(
+    async def list_chat_messages(
         self,
         chat_id: str,
         top: int | None = None,
-        skip: int | None = None,
-        search: str | None = None,
+        orderby: list[Literal["lastModifiedDateTime desc", "createdDateTime desc"]] | None = None,
         filter: str | None = None,
-        count: bool | None = None,
-        orderby: list[str] | None = None,
-        select: list[str] | None = None,
-        expand: list[str] | None = None,
     ) -> dict[str, Any]:
         """
-        Retrieves messages from a specific chat using its ID. Unlike `get_chat_message`, which fetches a single message, this function returns a collection and supports advanced querying for filtering, sorting, and pagination to refine the results.
+        Retrieves messages from a specific chat using its ID.
+        
+        Supported OData parameters with strict limitations:
+        - $top: Controls the number of items per response. Maximum allowed value is 50.
+        - $orderby: Currently supports 'lastModifiedDateTime desc' (default) and 'createdDateTime desc'. Ascending order is NOT supported.
+        - $filter: Sets the date range filter for 'lastModifiedDateTime' (supports gt/lt) and 'createdDateTime' (supports lt). 
+          Note: You can only filter results if 'orderby' is configured for the same property!
 
         Args:
-            chat_id (string): chat-id
-            top (integer): Show only the first n items Example: '50'.
-            skip (integer): Skip the first n items
-            search (string): Search items by search phrases
-            filter (string): Filter items by property values
-            count (boolean): Include count of items
-            orderby (array): Order items by property values
-            select (array): Select properties to be returned
-            expand (array): Expand related entities
+            chat_id (string): The unique identifier of the chat.
+            top (integer): Show only the first n items. Max 50.
+            orderby (array): Order items by property values. Restrict to supported descending sorts.
+            filter (string): Filter items by property values. Must match orderby property.
 
         Returns:
-            dict[str, Any]: Retrieved collection
+            dict[str, Any]: Retrieved collection of messages.
 
         Raises:
             HTTPStatusError: Raised when the API request fails with detailed error information including status code and response body.
 
         Tags:
-            chats.chatMessage
+            chats.chatMessage, list, read
         """
         if chat_id is None:
             raise ValueError("Missing required parameter 'chat-id'.")
         url = f"{self.base_url}/chats/{chat_id}/messages"
+        # Helper to format list params
+        def fmt(val):
+            return ",".join(val) if isinstance(val, list) else val
+
         query_params = {
-            k: v
+            k: fmt(v)
             for k, v in [
                 ("$top", top),
-                ("$skip", skip),
-                ("$search", search),
-                ("$filter", filter),
-                ("$count", count),
                 ("$orderby", orderby),
-                ("$select", select),
-                ("$expand", expand),
+                ("$filter", filter),
             ]
             if v is not None
         }
-        response = self._get(url, params=query_params)
+        response = await self._aget(url, params=query_params)
         return self._handle_response(response)
 
-    def get_chat_message(
-        self,
-        chat_id: str,
-        chatMessage_id: str,
-        select: list[str] | None = None,
-        expand: list[str] | None = None,
+    async def get_chat_message(
+        self, chat_id: str, chatMessage_id: str
     ) -> Any:
         """
-        Retrieves the full details of a single message from a specific chat using both chat and message IDs. This function targets an individual message, differentiating it from `list_chat_messages`, which retrieves a collection. Optional parameters can customize the response by selecting specific properties or expanding entities.
+        Retrieves the full details of a single message from a specific chat using both chat and message IDs.
+        Note: The Microsoft Graph API for this endpoint does NOT support OData query parameters like $select or $expand.
 
         Args:
-            chat_id (string): chat-id
-            chatMessage_id (string): chatMessage-id
-            select (array): Select properties to be returned
-            expand (array): Expand related entities
+            chat_id (string): The unique identifier of the chat.
+            chatMessage_id (string): The unique identifier of the message.
 
         Returns:
-            Any: Retrieved navigation property
+            Any: Retrieved chatMessage entity.
 
         Raises:
             HTTPStatusError: Raised when the API request fails with detailed error information including status code and response body.
 
         Tags:
-            chats.chatMessage
+            chats.chatMessage, read
         """
         if chat_id is None:
             raise ValueError("Missing required parameter 'chat-id'.")
         if chatMessage_id is None:
             raise ValueError("Missing required parameter 'chatMessage-id'.")
         url = f"{self.base_url}/chats/{chat_id}/messages/{chatMessage_id}"
-        query_params = {
-            k: v for k, v in [("$select", select), ("$expand", expand)] if v is not None
-        }
-        response = self._get(url, params=query_params)
+        
+        # This endpoint explicitly does not support OData params
+        response = await self._aget(url)
         return self._handle_response(response)
 
-    def list_chat_message_replies(
-        self,
-        chat_id: str,
-        chatMessage_id: str,
-        top: int | None = None,
-        skip: int | None = None,
-        search: str | None = None,
-        filter: str | None = None,
-        count: bool | None = None,
-        orderby: list[str] | None = None,
-        select: list[str] | None = None,
-        expand: list[str] | None = None,
-    ) -> dict[str, Any]:
+    async def send_chat_message(self, chat_id: str, content: str) -> dict[str, Any]:
         """
-        Retrieves all replies for a specific message within a chat, using the parent message's ID. This function, unlike `get_chat_reply_details`, returns a collection and supports OData query parameters for advanced filtering, sorting, and pagination of the results.
-
+        Posts a new message to a specific Microsoft Teams chat using its unique ID.
+        
         Args:
-            chat_id (string): chat-id
-            chatMessage_id (string): chatMessage-id
-            top (integer): Show only the first n items Example: '50'.
-            skip (integer): Skip the first n items
-            search (string): Search items by search phrases
-            filter (string): Filter items by property values
-            count (boolean): Include count of items
-            orderby (array): Order items by property values
-            select (array): Select properties to be returned
-            expand (array): Expand related entities
+            chat_id (string): The unique identifier of the chat.
+            content (string): The message content to send (plain text or HTML).
 
         Returns:
-            dict[str, Any]: Retrieved collection
+            dict[str, Any]: A dictionary containing the API response for the sent message, including its ID.
 
         Raises:
-            HTTPStatusError: Raised when the API request fails with detailed error information including status code and response body.
+            HTTPStatusError: If the API request fails due to invalid ID, permissions, etc.
 
         Tags:
-            chats.chatMessage
+            chats.chatMessage, create, send, important
         """
         if chat_id is None:
             raise ValueError("Missing required parameter 'chat-id'.")
-        if chatMessage_id is None:
-            raise ValueError("Missing required parameter 'chatMessage-id'.")
-        url = f"{self.base_url}/chats/{chat_id}/messages/{chatMessage_id}/replies"
-        query_params = {
-            k: v
-            for k, v in [
-                ("$top", top),
-                ("$skip", skip),
-                ("$search", search),
-                ("$filter", filter),
-                ("$count", count),
-                ("$orderby", orderby),
-                ("$select", select),
-                ("$expand", expand),
-            ]
-            if v is not None
-        }
-        response = self._get(url, params=query_params)
+        
+        url = f"{self.base_url}/chats/{chat_id}/messages"
+        payload = {"body": {"content": content}}
+        
+        response = await self._apost(url, data=payload)
         return self._handle_response(response)
 
-    def reply_to_chat_message(
-        self,
-        chat_id: str,
-        chatMessage_id: str,
-        id: str | None = None,
-        attachments: list[dict[str, dict[str, Any]]] | None = None,
-        body: dict[str, dict[str, Any]] | None = None,
-        channelIdentity: dict[str, dict[str, Any]] | None = None,
-        chatId: str | None = None,
-        createdDateTime: str | None = None,
-        deletedDateTime: str | None = None,
-        etag: str | None = None,
-        eventDetail: dict[str, dict[str, Any]] | None = None,
-        from_: Any | None = None,
-        importance: str | None = None,
-        lastEditedDateTime: str | None = None,
-        lastModifiedDateTime: str | None = None,
-        locale: str | None = None,
-        mentions: list[dict[str, dict[str, Any]]] | None = None,
-        messageHistory: list[dict[str, dict[str, Any]]] | None = None,
-        messageType: str | None = None,
-        policyViolation: dict[str, dict[str, Any]] | None = None,
-        reactions: list[dict[str, dict[str, Any]]] | None = None,
-        replyToId: str | None = None,
-        subject: str | None = None,
-        summary: str | None = None,
-        webUrl: str | None = None,
-        hostedContents: list[Any] | None = None,
-        replies: list[Any] | None = None,
-    ) -> Any:
-        """
-        Posts a reply to a specific message within a chat. This comprehensive function allows for detailed configuration of the reply's properties, like its body and attachments. It differs from `reply_to_channel_message`, which sends simpler replies to messages within team channels.
-
-        Args:
-            chat_id (string): chat-id
-            chatMessage_id (string): chatMessage-id
-            id (string): The unique identifier for an entity. Read-only.
-            attachments (array): References to attached objects like files, tabs, meetings etc.
-            body (object): body
-            channelIdentity (object): channelIdentity
-            chatId (string): If the message was sent in a chat, represents the identity of the chat.
-            createdDateTime (string): Timestamp of when the chat message was created.
-            deletedDateTime (string): Read only. Timestamp at which the chat message was deleted, or null if not deleted.
-            etag (string): Read-only. Version number of the chat message.
-            eventDetail (object): eventDetail
-            from_ (string): from
-            importance (string): importance
-            lastEditedDateTime (string): Read only. Timestamp when edits to the chat message were made. Triggers an 'Edited' flag in the Teams UI. If no edits are made the value is null.
-            lastModifiedDateTime (string): Read only. Timestamp when the chat message is created (initial setting) or modified, including when a reaction is added or removed.
-            locale (string): Locale of the chat message set by the client. Always set to en-us.
-            mentions (array): List of entities mentioned in the chat message. Supported entities are: user, bot, team, channel, chat, and tag.
-            messageHistory (array): List of activity history of a message item, including modification time and actions, such as reactionAdded, reactionRemoved, or reaction changes, on the message.
-            messageType (string): messageType
-            policyViolation (object): policyViolation
-            reactions (array): Reactions for this chat message (for example, Like).
-            replyToId (string): Read-only. ID of the parent chat message or root chat message of the thread. (Only applies to chat messages in channels, not chats.)
-            subject (string): The subject of the chat message, in plaintext.
-            summary (string): Summary text of the chat message that could be used for push notifications and summary views or fall back views. Only applies to channel chat messages, not chat messages in a chat.
-            webUrl (string): Read-only. Link to the message in Microsoft Teams.
-            hostedContents (array): Content in a message hosted by Microsoft Teams - for example, images or code snippets.
-            replies (array): Replies for a specified message. Supports $expand for channel messages.
-
-        Returns:
-            Any: Created navigation property.
-
-        Raises:
-            HTTPStatusError: Raised when the API request fails with detailed error information including status code and response body.
+# Channels
 
-        Tags:
-            chats.chatMessage
-        """
-        if chat_id is None:
-            raise ValueError("Missing required parameter 'chat-id'.")
-        if chatMessage_id is None:
-            raise ValueError("Missing required parameter 'chatMessage-id'.")
-        request_body_data = None
-        request_body_data = {
-            "id": id,
-            "attachments": attachments,
-            "body": body,
-            "channelIdentity": channelIdentity,
-            "chatId": chatId,
-            "createdDateTime": createdDateTime,
-            "deletedDateTime": deletedDateTime,
-            "etag": etag,
-            "eventDetail": eventDetail,
-            "from": from_,
-            "importance": importance,
-            "lastEditedDateTime": lastEditedDateTime,
-            "lastModifiedDateTime": lastModifiedDateTime,
-            "locale": locale,
-            "mentions": mentions,
-            "messageHistory": messageHistory,
-            "messageType": messageType,
-            "policyViolation": policyViolation,
-            "reactions": reactions,
-            "replyToId": replyToId,
-            "subject": subject,
-            "summary": summary,
-            "webUrl": webUrl,
-            "hostedContents": hostedContents,
-            "replies": replies,
-        }
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
-        url = f"{self.base_url}/chats/{chat_id}/messages/{chatMessage_id}/replies"
-        query_params = {}
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
-        return self._handle_response(response)
-
-    def get_chat_reply_details(
+    async def list_all_channels(
         self,
-        chat_id: str,
-        chatMessage_id: str,
-        chatMessage_id1: str,
+        team_id: str,
+        filter: str | None = None,
         select: list[str] | None = None,
         expand: list[str] | None = None,
-    ) -> Any:
+    ) -> dict[str, Any]:
         """
-        Retrieves a specific reply from a chat message thread using the chat, parent message, and reply IDs. Unlike `list_chat_message_replies`, which fetches all replies, this function targets a single reply for detailed information, allowing for customized field selection.
+        Retrieves the list of channels either in this team or shared with this team (incoming channels).
+        Supported OData parameters:
+        - $filter: Filter by property values.
+        - $select: Select specific properties to return (recommended for performance).
+        - $expand: Expand related entities.
 
         Args:
-            chat_id (string): chat-id
-            chatMessage_id (string): chatMessage-id
-            chatMessage_id1 (string): chatMessage-id1
-            select (array): Select properties to be returned
-            expand (array): Expand related entities
+            team_id (string): The unique identifier of the team.
+            filter (string): Filter items by property values.
+            select (array): Select properties to be returned.
+            expand (array): Expand related entities.
 
         Returns:
-            Any: Retrieved navigation property
+            dict[str, Any]: Retrieved collection of channels.
 
         Raises:
-            HTTPStatusError: Raised when the API request fails with detailed error information including status code and response body.
+            HTTPStatusError: If the API request fails.
 
         Tags:
-            chats.chatMessage
+            teams.channel, list, read
         """
-        if chat_id is None:
-            raise ValueError("Missing required parameter 'chat-id'.")
-        if chatMessage_id is None:
-            raise ValueError("Missing required parameter 'chatMessage-id'.")
-        if chatMessage_id1 is None:
-            raise ValueError("Missing required parameter 'chatMessage-id1'.")
-        url = f"{self.base_url}/chats/{chat_id}/messages/{chatMessage_id}/replies/{chatMessage_id1}"
+        if team_id is None:
+            raise ValueError("Missing required parameter 'team-id'.")
+
+        url = f"{self.base_url}/teams/{team_id}/allChannels"
+
+        # Helper to format list params
+        def fmt(val):
+            return ",".join(val) if isinstance(val, list) else val
+
         query_params = {
-            k: v for k, v in [("$select", select), ("$expand", expand)] if v is not None
+            k: fmt(v)
+            for k, v in [
+                ("$filter", filter),
+                ("$select", select),
+                ("$expand", expand),
+            ]
+            if v is not None
         }
-        response = self._get(url, params=query_params)
+
+        response = await self._aget(url, params=query_params)
         return self._handle_response(response)
 
-    def create_team_from_group(
+    async def get_channel(
         self,
-        group_id: str,
-        id: str | None = None,
-        classification: str | None = None,
-        createdDateTime: str | None = None,
-        description: str | None = None,
-        displayName: str | None = None,
-        firstChannelName: str | None = None,
-        funSettings: dict[str, dict[str, Any]] | None = None,
-        guestSettings: dict[str, dict[str, Any]] | None = None,
-        internalId: str | None = None,
-        isArchived: bool | None = None,
-        memberSettings: dict[str, dict[str, Any]] | None = None,
-        messagingSettings: dict[str, dict[str, Any]] | None = None,
-        specialization: str | None = None,
-        summary: dict[str, dict[str, Any]] | None = None,
-        tenantId: str | None = None,
-        visibility: str | None = None,
-        webUrl: str | None = None,
-        allChannels: list[Any] | None = None,
-        channels: list[Any] | None = None,
-        group: Any | None = None,
-        incomingChannels: list[Any] | None = None,
-        installedApps: list[Any] | None = None,
-        members: list[Any] | None = None,
-        operations: list[Any] | None = None,
-        permissionGrants: list[Any] | None = None,
-        photo: Any | None = None,
-        primaryChannel: Any | None = None,
-        schedule: Any | None = None,
-        tags: list[Any] | None = None,
-        template: Any | None = None,
-    ) -> Any:
+        team_id: str,
+        channel_id: str,
+        select: list[str] | None = None,
+        expand: list[str] | None = None,
+    ) -> dict[str, Any]:
         """
-        Enables Microsoft Teams functionality for a pre-existing Microsoft 365 group using its ID. This 'team-ifies' the group, allowing optional configuration of team properties. It differs from `create_team`, which provisions both a new team and its associated group simultaneously.
+        Retrieve the properties and relationships of a channel.
+        Supported OData parameters:
+        - $select: Select specific properties to return (recommended for performance).
+        - $expand: Expand related entities.
 
         Args:
-            group_id (string): group-id
-            id (string): The unique identifier for an entity. Read-only.
-            classification (string): An optional label. Typically describes the data or business sensitivity of the team. Must match one of a preconfigured set in the tenant's directory.
-            createdDateTime (string): Timestamp at which the team was created.
-            description (string): An optional description for the team. Maximum length: 1,024 characters.
-            displayName (string): The name of the team.
-            firstChannelName (string): The name of the first channel in the team. This is an optional property, only used during team creation and isn't returned in methods to get and list teams.
-            funSettings (object): funSettings
-            guestSettings (object): guestSettings
-            internalId (string): A unique ID for the team that was used in a few places such as the audit log/Office 365 Management Activity API.
-            isArchived (boolean): Whether this team is in read-only mode.
-            memberSettings (object): memberSettings
-            messagingSettings (object): messagingSettings
-            specialization (string): specialization
-            summary (object): summary
-            tenantId (string): The ID of the Microsoft Entra tenant.
-            visibility (string): visibility
-            webUrl (string): A hyperlink that goes to the team in the Microsoft Teams client. You get this URL when you right-click a team in the Microsoft Teams client and select Get link to team. This URL should be treated as an opaque blob, and not parsed.
-            allChannels (array): List of channels either hosted in or shared with the team (incoming channels).
-            channels (array): The collection of channels and messages associated with the team.
-            group (string): group
-            incomingChannels (array): List of channels shared with the team.
-            installedApps (array): The apps installed in this team.
-            members (array): Members and owners of the team.
-            operations (array): The async operations that ran or are running on this team.
-            permissionGrants (array): A collection of permissions granted to apps to access the team.
-            photo (string): photo
-            primaryChannel (string): primaryChannel
-            schedule (string): schedule
-            tags (array): The tags associated with the team.
-            template (string): template
+            team_id (string): The unique identifier of the team.
+            channel_id (string): The unique identifier of the channel.
+            select (array): Select properties to be returned.
+            expand (array): Expand related entities.
 
         Returns:
-            Any: Success
+            dict[str, Any]: Retrieved channel entity.
 
         Raises:
-            HTTPStatusError: Raised when the API request fails with detailed error information including status code and response body.
+            HTTPStatusError: If the API request fails.
 
         Tags:
-            groups.team
+            teams.channel, read
         """
-        if group_id is None:
-            raise ValueError("Missing required parameter 'group-id'.")
-        request_body_data = None
-        request_body_data = {
-            "id": id,
-            "classification": classification,
-            "createdDateTime": createdDateTime,
-            "description": description,
-            "displayName": displayName,
-            "firstChannelName": firstChannelName,
-            "funSettings": funSettings,
-            "guestSettings": guestSettings,
-            "internalId": internalId,
-            "isArchived": isArchived,
-            "memberSettings": memberSettings,
-            "messagingSettings": messagingSettings,
-            "specialization": specialization,
-            "summary": summary,
-            "tenantId": tenantId,
-            "visibility": visibility,
-            "webUrl": webUrl,
-            "allChannels": allChannels,
-            "channels": channels,
-            "group": group,
-            "incomingChannels": incomingChannels,
-            "installedApps": installedApps,
-            "members": members,
-            "operations": operations,
-            "permissionGrants": permissionGrants,
-            "photo": photo,
-            "primaryChannel": primaryChannel,
-            "schedule": schedule,
-            "tags": tags,
-            "template": template,
-        }
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
-        url = f"{self.base_url}/groups/{group_id}/team"
-        query_params = {}
-        response = self._put(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
-        return self._handle_response(response)
-
-    def create_team(
-        self,
-        id: str | None = None,
-        classification: str | None = None,
-        createdDateTime: str | None = None,
-        description: str | None = None,
-        displayName: str | None = None,
-        firstChannelName: str | None = None,
-        funSettings: dict[str, dict[str, Any]] | None = None,
-        guestSettings: dict[str, dict[str, Any]] | None = None,
-        internalId: str | None = None,
-        isArchived: bool | None = None,
-        memberSettings: dict[str, dict[str, Any]] | None = None,
-        messagingSettings: dict[str, dict[str, Any]] | None = None,
-        specialization: str | None = None,
-        summary: dict[str, dict[str, Any]] | None = None,
-        tenantId: str | None = None,
-        visibility: str | None = None,
-        webUrl: str | None = None,
-        allChannels: list[Any] | None = None,
-        channels: list[Any] | None = None,
-        group: Any | None = None,
-        incomingChannels: list[Any] | None = None,
-        installedApps: list[Any] | None = None,
-        members: list[Any] | None = None,
-        operations: list[Any] | None = None,
-        permissionGrants: list[Any] | None = None,
-        photo: Any | None = None,
-        primaryChannel: Any | None = None,
-        schedule: Any | None = None,
-        tags: list[Any] | None = None,
-        template: Any | None = None,
-    ) -> Any:
-        """
-        Creates a new Microsoft Team and its associated Microsoft 365 group. This method builds a team from scratch, allowing specification of initial properties like display name, description, and members. It differs from `create_team_from_group`, which enables team functionality for an existing group.
-
-        Args:
-            id (string): The unique identifier for an entity. Read-only.
-            classification (string): An optional label. Typically describes the data or business sensitivity of the team. Must match one of a preconfigured set in the tenant's directory.
-            createdDateTime (string): Timestamp at which the team was created.
-            description (string): An optional description for the team. Maximum length: 1,024 characters.
-            displayName (string): The name of the team.
-            firstChannelName (string): The name of the first channel in the team. This is an optional property, only used during team creation and isn't returned in methods to get and list teams.
-            funSettings (object): funSettings
-            guestSettings (object): guestSettings
-            internalId (string): A unique ID for the team that was used in a few places such as the audit log/Office 365 Management Activity API.
-            isArchived (boolean): Whether this team is in read-only mode.
-            memberSettings (object): memberSettings
-            messagingSettings (object): messagingSettings
-            specialization (string): specialization
-            summary (object): summary
-            tenantId (string): The ID of the Microsoft Entra tenant.
-            visibility (string): visibility
-            webUrl (string): A hyperlink that goes to the team in the Microsoft Teams client. You get this URL when you right-click a team in the Microsoft Teams client and select Get link to team. This URL should be treated as an opaque blob, and not parsed.
-            allChannels (array): List of channels either hosted in or shared with the team (incoming channels).
-            channels (array): The collection of channels and messages associated with the team.
-            group (string): group
-            incomingChannels (array): List of channels shared with the team.
-            installedApps (array): The apps installed in this team.
-            members (array): Members and owners of the team.
-            operations (array): The async operations that ran or are running on this team.
-            permissionGrants (array): A collection of permissions granted to apps to access the team.
-            photo (string): photo
-            primaryChannel (string): primaryChannel
-            schedule (string): schedule
-            tags (array): The tags associated with the team.
-            template (string): template
+        if team_id is None:
+            raise ValueError("Missing required parameter 'team-id'.")
+        if channel_id is None:
+            raise ValueError("Missing required parameter 'channel-id'.")
 
-        Returns:
-            Any: Created entity
+        url = f"{self.base_url}/teams/{team_id}/channels/{channel_id}"
 
-        Raises:
-            HTTPStatusError: Raised when the API request fails with detailed error information including status code and response body.
+        # Helper to format list params
+        def fmt(val):
+            return ",".join(val) if isinstance(val, list) else val
 
-        Tags:
-            teams.team
-        """
-        request_body_data = None
-        request_body_data = {
-            "id": id,
-            "classification": classification,
-            "createdDateTime": createdDateTime,
-            "description": description,
-            "displayName": displayName,
-            "firstChannelName": firstChannelName,
-            "funSettings": funSettings,
-            "guestSettings": guestSettings,
-            "internalId": internalId,
-            "isArchived": isArchived,
-            "memberSettings": memberSettings,
-            "messagingSettings": messagingSettings,
-            "specialization": specialization,
-            "summary": summary,
-            "tenantId": tenantId,
-            "visibility": visibility,
-            "webUrl": webUrl,
-            "allChannels": allChannels,
-            "channels": channels,
-            "group": group,
-            "incomingChannels": incomingChannels,
-            "installedApps": installedApps,
-            "members": members,
-            "operations": operations,
-            "permissionGrants": permissionGrants,
-            "photo": photo,
-            "primaryChannel": primaryChannel,
-            "schedule": schedule,
-            "tags": tags,
-            "template": template,
-        }
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
+        query_params = {
+            k: fmt(v)
+            for k, v in [
+                ("$select", select),
+                ("$expand", expand),
+            ]
+            if v is not None
         }
-        url = f"{self.base_url}/teams"
-        query_params = {}
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
+
+        response = await self._aget(url, params=query_params)
         return self._handle_response(response)
 
-    def get_channel_details(
+    async def get_primary_channel(
         self,
         team_id: str,
-        channel_id: str,
         select: list[str] | None = None,
         expand: list[str] | None = None,
-    ) -> Any:
+    ) -> dict[str, Any]:
         """
-        Retrieves detailed information for a specific channel within a Microsoft Teams team, identified by both team and channel IDs. Optional parameters can select specific properties or expand related entities in the response, distinguishing it from list_channels_for_team, which retrieves a collection of channels.
+        Retrieve the default General channel of a team.
+        Supported OData parameters:
+        - $select: Select specific properties to return.
+        - $expand: Expand related entities.
 
         Args:
-            team_id (string): team-id
-            channel_id (string): channel-id
-            select (array): Select properties to be returned
-            expand (array): Expand related entities
+            team_id (string): The unique identifier of the team.
+            select (array): Select properties to be returned.
+            expand (array): Expand related entities.
 
         Returns:
-            Any: Retrieved navigation property
+            dict[str, Any]: Retrieved channel entity.
 
         Raises:
-            HTTPStatusError: Raised when the API request fails with detailed error information including status code and response body.
+            HTTPStatusError: If the API request fails.
 
         Tags:
-            teams.channel
+            teams.channel, read
         """
         if team_id is None:
             raise ValueError("Missing required parameter 'team-id'.")
-        if channel_id is None:
-            raise ValueError("Missing required parameter 'channel-id'.")
-        url = f"{self.base_url}/teams/{team_id}/channels/{channel_id}"
+
+        url = f"{self.base_url}/teams/{team_id}/primaryChannel"
+
+        # Helper to format list params
+        def fmt(val):
+            return ",".join(val) if isinstance(val, list) else val
+
         query_params = {
-            k: v for k, v in [("$select", select), ("$expand", expand)] if v is not None
+            k: fmt(v)
+            for k, v in [
+                ("$select", select),
+                ("$expand", expand),
+            ]
+            if v is not None
         }
-        response = self._get(url, params=query_params)
+
+        response = await self._aget(url, params=query_params)
         return self._handle_response(response)
 
-    def update_channel_message(
+    async def send_channel_message(
         self,
         team_id: str,
         channel_id: str,
-        chatMessage_id: str,
-        id: str | None = None,
-        attachments: list[dict[str, dict[str, Any]]] | None = None,
-        body: dict[str, dict[str, Any]] | None = None,
-        channelIdentity: dict[str, dict[str, Any]] | None = None,
-        chatId: str | None = None,
-        createdDateTime: str | None = None,
-        deletedDateTime: str | None = None,
-        etag: str | None = None,
-        eventDetail: dict[str, dict[str, Any]] | None = None,
-        from_: Any | None = None,
-        importance: str | None = None,
-        lastEditedDateTime: str | None = None,
-        lastModifiedDateTime: str | None = None,
-        locale: str | None = None,
-        mentions: list[dict[str, dict[str, Any]]] | None = None,
-        messageHistory: list[dict[str, dict[str, Any]]] | None = None,
-        messageType: str | None = None,
-        policyViolation: dict[str, dict[str, Any]] | None = None,
-        reactions: list[dict[str, dict[str, Any]]] | None = None,
-        replyToId: str | None = None,
-        subject: str | None = None,
-        summary: str | None = None,
-        webUrl: str | None = None,
-        hostedContents: list[Any] | None = None,
-        replies: list[Any] | None = None,
-    ) -> Any:
+        content: str,
+    ) -> dict[str, Any]:
         """
-        Updates an existing message within a Microsoft Teams channel, identified by team, channel, and message IDs. This function modifies the original message's properties, like its body, via a PATCH request, distinguishing it from functions that create new messages or update replies.
+        Posts a new message to a specific channel in a team.
 
         Args:
-            team_id (string): team-id
-            channel_id (string): channel-id
-            chatMessage_id (string): chatMessage-id
-            id (string): The unique identifier for an entity. Read-only.
-            attachments (array): References to attached objects like files, tabs, meetings etc.
-            body (object): body
-            channelIdentity (object): channelIdentity
-            chatId (string): If the message was sent in a chat, represents the identity of the chat.
-            createdDateTime (string): Timestamp of when the chat message was created.
-            deletedDateTime (string): Read only. Timestamp at which the chat message was deleted, or null if not deleted.
-            etag (string): Read-only. Version number of the chat message.
-            eventDetail (object): eventDetail
-            from_ (string): from
-            importance (string): importance
-            lastEditedDateTime (string): Read only. Timestamp when edits to the chat message were made. Triggers an 'Edited' flag in the Teams UI. If no edits are made the value is null.
-            lastModifiedDateTime (string): Read only. Timestamp when the chat message is created (initial setting) or modified, including when a reaction is added or removed.
-            locale (string): Locale of the chat message set by the client. Always set to en-us.
-            mentions (array): List of entities mentioned in the chat message. Supported entities are: user, bot, team, channel, chat, and tag.
-            messageHistory (array): List of activity history of a message item, including modification time and actions, such as reactionAdded, reactionRemoved, or reaction changes, on the message.
-            messageType (string): messageType
-            policyViolation (object): policyViolation
-            reactions (array): Reactions for this chat message (for example, Like).
-            replyToId (string): Read-only. ID of the parent chat message or root chat message of the thread. (Only applies to chat messages in channels, not chats.)
-            subject (string): The subject of the chat message, in plaintext.
-            summary (string): Summary text of the chat message that could be used for push notifications and summary views or fall back views. Only applies to channel chat messages, not chat messages in a chat.
-            webUrl (string): Read-only. Link to the message in Microsoft Teams.
-            hostedContents (array): Content in a message hosted by Microsoft Teams - for example, images or code snippets.
-            replies (array): Replies for a specified message. Supports $expand for channel messages.
+            team_id (string): The unique identifier of the team.
+            channel_id (string): The unique identifier of the channel.
+            content (string): The message content to send (plain text or HTML).
 
         Returns:
-            Any: Success
+            dict[str, Any]: A dictionary containing the API response for the sent message, including its ID.
 
         Raises:
-            HTTPStatusError: Raised when the API request fails with detailed error information including status code and response body.
+            HTTPStatusError: If the API request fails.
 
         Tags:
-            teams.channel
+            teams.channel, channel.message, create, send
         """
         if team_id is None:
             raise ValueError("Missing required parameter 'team-id'.")
         if channel_id is None:
             raise ValueError("Missing required parameter 'channel-id'.")
-        if chatMessage_id is None:
-            raise ValueError("Missing required parameter 'chatMessage-id'.")
-        request_body_data = None
-        request_body_data = {
-            "id": id,
-            "attachments": attachments,
-            "body": body,
-            "channelIdentity": channelIdentity,
-            "chatId": chatId,
-            "createdDateTime": createdDateTime,
-            "deletedDateTime": deletedDateTime,
-            "etag": etag,
-            "eventDetail": eventDetail,
-            "from": from_,
-            "importance": importance,
-            "lastEditedDateTime": lastEditedDateTime,
-            "lastModifiedDateTime": lastModifiedDateTime,
-            "locale": locale,
-            "mentions": mentions,
-            "messageHistory": messageHistory,
-            "messageType": messageType,
-            "policyViolation": policyViolation,
-            "reactions": reactions,
-            "replyToId": replyToId,
-            "subject": subject,
-            "summary": summary,
-            "webUrl": webUrl,
-            "hostedContents": hostedContents,
-            "replies": replies,
-        }
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
-        url = f"{self.base_url}/teams/{team_id}/channels/{channel_id}/messages/{chatMessage_id}"
-        query_params = {}
-        response = self._patch(url, data=request_body_data, params=query_params)
+
+        url = f"{self.base_url}/teams/{team_id}/channels/{channel_id}/messages"
+        payload = {"body": {"content": content}}
+
+        response = await self._apost(url, data=payload)
         return self._handle_response(response)
 
-    def update_channel_message_reply(
+    async def reply_to_channel_message(
         self,
         team_id: str,
         channel_id: str,
-        chatMessage_id: str,
-        chatMessage_id1: str,
-        id: str | None = None,
-        attachments: list[dict[str, dict[str, Any]]] | None = None,
-        body: dict[str, dict[str, Any]] | None = None,
-        channelIdentity: dict[str, dict[str, Any]] | None = None,
-        chatId: str | None = None,
-        createdDateTime: str | None = None,
-        deletedDateTime: str | None = None,
-        etag: str | None = None,
-        eventDetail: dict[str, dict[str, Any]] | None = None,
-        from_: Any | None = None,
-        importance: str | None = None,
-        lastEditedDateTime: str | None = None,
-        lastModifiedDateTime: str | None = None,
-        locale: str | None = None,
-        mentions: list[dict[str, dict[str, Any]]] | None = None,
-        messageHistory: list[dict[str, dict[str, Any]]] | None = None,
-        messageType: str | None = None,
-        policyViolation: dict[str, dict[str, Any]] | None = None,
-        reactions: list[dict[str, dict[str, Any]]] | None = None,
-        replyToId: str | None = None,
-        subject: str | None = None,
-        summary: str | None = None,
-        webUrl: str | None = None,
-        hostedContents: list[Any] | None = None,
-        replies: list[Any] | None = None,
-    ) -> Any:
+        message_id: str,
+        content: str,
+    ) -> dict[str, Any]:
         """
-        Updates an existing reply to a specific message within a Microsoft Teams channel. It identifies the target reply using team, channel, parent message, and reply IDs, modifying its properties (e.g., body content, attachments) via a PATCH request.
+        Sends a reply to an existing message in a channel.
 
         Args:
-            team_id (string): team-id
-            channel_id (string): channel-id
-            chatMessage_id (string): chatMessage-id
-            chatMessage_id1 (string): chatMessage-id1
-            id (string): The unique identifier for an entity. Read-only.
-            attachments (array): References to attached objects like files, tabs, meetings etc.
-            body (object): body
-            channelIdentity (object): channelIdentity
-            chatId (string): If the message was sent in a chat, represents the identity of the chat.
-            createdDateTime (string): Timestamp of when the chat message was created.
-            deletedDateTime (string): Read only. Timestamp at which the chat message was deleted, or null if not deleted.
-            etag (string): Read-only. Version number of the chat message.
-            eventDetail (object): eventDetail
-            from_ (string): from
-            importance (string): importance
-            lastEditedDateTime (string): Read only. Timestamp when edits to the chat message were made. Triggers an 'Edited' flag in the Teams UI. If no edits are made the value is null.
-            lastModifiedDateTime (string): Read only. Timestamp when the chat message is created (initial setting) or modified, including when a reaction is added or removed.
-            locale (string): Locale of the chat message set by the client. Always set to en-us.
-            mentions (array): List of entities mentioned in the chat message. Supported entities are: user, bot, team, channel, chat, and tag.
-            messageHistory (array): List of activity history of a message item, including modification time and actions, such as reactionAdded, reactionRemoved, or reaction changes, on the message.
-            messageType (string): messageType
-            policyViolation (object): policyViolation
-            reactions (array): Reactions for this chat message (for example, Like).
-            replyToId (string): Read-only. ID of the parent chat message or root chat message of the thread. (Only applies to chat messages in channels, not chats.)
-            subject (string): The subject of the chat message, in plaintext.
-            summary (string): Summary text of the chat message that could be used for push notifications and summary views or fall back views. Only applies to channel chat messages, not chat messages in a chat.
-            webUrl (string): Read-only. Link to the message in Microsoft Teams.
-            hostedContents (array): Content in a message hosted by Microsoft Teams - for example, images or code snippets.
-            replies (array): Replies for a specified message. Supports $expand for channel messages.
+            team_id (string): The unique identifier of the team.
+            channel_id (string): The unique identifier of the channel.
+            message_id (string): The unique identifier of the message to reply to.
+            content (string): The reply content to send (plain text or HTML).
 
         Returns:
-            Any: Success
+            dict[str, Any]: A dictionary containing the API response for the created reply.
 
         Raises:
-            HTTPStatusError: Raised when the API request fails with detailed error information including status code and response body.
+            HTTPStatusError: If the API request fails.
 
         Tags:
-            teams.channel
+            teams.channel, channel.message, reply, create, send
         """
         if team_id is None:
             raise ValueError("Missing required parameter 'team-id'.")
         if channel_id is None:
             raise ValueError("Missing required parameter 'channel-id'.")
-        if chatMessage_id is None:
-            raise ValueError("Missing required parameter 'chatMessage-id'.")
-        if chatMessage_id1 is None:
-            raise ValueError("Missing required parameter 'chatMessage-id1'.")
-        request_body_data = None
-        request_body_data = {
-            "id": id,
-            "attachments": attachments,
-            "body": body,
-            "channelIdentity": channelIdentity,
-            "chatId": chatId,
-            "createdDateTime": createdDateTime,
-            "deletedDateTime": deletedDateTime,
-            "etag": etag,
-            "eventDetail": eventDetail,
-            "from": from_,
-            "importance": importance,
-            "lastEditedDateTime": lastEditedDateTime,
-            "lastModifiedDateTime": lastModifiedDateTime,
-            "locale": locale,
-            "mentions": mentions,
-            "messageHistory": messageHistory,
-            "messageType": messageType,
-            "policyViolation": policyViolation,
-            "reactions": reactions,
-            "replyToId": replyToId,
-            "subject": subject,
-            "summary": summary,
-            "webUrl": webUrl,
-            "hostedContents": hostedContents,
-            "replies": replies,
-        }
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
-        url = f"{self.base_url}/teams/{team_id}/channels/{channel_id}/messages/{chatMessage_id}/replies/{chatMessage_id1}"
-        query_params = {}
-        response = self._patch(url, data=request_body_data, params=query_params)
+        if message_id is None:
+            raise ValueError("Missing required parameter 'message-id'.")
+
+        url = f"{self.base_url}/teams/{team_id}/channels/{channel_id}/messages/{message_id}/replies"
+        payload = {"body": {"content": content}}
+
+        response = await self._apost(url, data=payload)
         return self._handle_response(response)
 
-    def list_channel_tabs(
+    async def list_pinned_chat_messages(
         self,
-        team_id: str,
-        channel_id: str,
-        top: int | None = None,
-        skip: int | None = None,
-        search: str | None = None,
-        filter: str | None = None,
-        count: bool | None = None,
-        orderby: list[str] | None = None,
-        select: list[str] | None = None,
+        chat_id: str,
         expand: list[str] | None = None,
     ) -> dict[str, Any]:
         """
-        Retrieves a collection of tabs from a specified channel within a Microsoft Teams team. Unlike `get_channel_tab_details`, which fetches a single tab, this function lists all tabs and supports advanced OData query parameters for filtering, sorting, and pagination of the entire collection.
+        Get a list of pinned messages in a chat.
+        Supported OData parameters:
+        - $expand: Expand related entities (e.g., 'message').
 
         Args:
-            team_id (string): team-id
-            channel_id (string): channel-id
-            top (integer): Show only the first n items Example: '50'.
-            skip (integer): Skip the first n items
-            search (string): Search items by search phrases
-            filter (string): Filter items by property values
-            count (boolean): Include count of items
-            orderby (array): Order items by property values
-            select (array): Select properties to be returned
-            expand (array): Expand related entities
+            chat_id (string): The unique identifier of the chat.
+            expand (array): Expand related entities.
 
         Returns:
-            dict[str, Any]: Retrieved collection
+            dict[str, Any]: Retrieved collection of pinned messages.
 
         Raises:
-            HTTPStatusError: Raised when the API request fails with detailed error information including status code and response body.
+            HTTPStatusError: If the API request fails.
 
         Tags:
-            teams.channel
+            teams.chat, pinned_message, list, read
         """
-        if team_id is None:
-            raise ValueError("Missing required parameter 'team-id'.")
-        if channel_id is None:
-            raise ValueError("Missing required parameter 'channel-id'.")
-        url = f"{self.base_url}/teams/{team_id}/channels/{channel_id}/tabs"
+        if chat_id is None:
+            raise ValueError("Missing required parameter 'chat-id'.")
+
+        url = f"{self.base_url}/chats/{chat_id}/pinnedMessages"
+
+        # Helper to format list params
+        def fmt(val):
+            return ",".join(val) if isinstance(val, list) else val
+
         query_params = {
-            k: v
+            k: fmt(v)
             for k, v in [
-                ("$top", top),
-                ("$skip", skip),
-                ("$search", search),
-                ("$filter", filter),
-                ("$count", count),
-                ("$orderby", orderby),
-                ("$select", select),
                 ("$expand", expand),
             ]
             if v is not None
         }
-        response = self._get(url, params=query_params)
+
+        response = await self._aget(url, params=query_params)
         return self._handle_response(response)
 
-    def create_channel_tab(
+    async def pin_chat_message(
         self,
-        team_id: str,
-        channel_id: str,
-        id: str | None = None,
-        configuration: dict[str, dict[str, Any]] | None = None,
-        displayName: str | None = None,
-        webUrl: str | None = None,
-        teamsApp: Any | None = None,
-    ) -> Any:
+        chat_id: str,
+        message_id: str,
+    ) -> dict[str, Any]:
         """
-        Creates a new tab in a specified Microsoft Teams channel using team and channel IDs. This function configures the tab's initial properties, such as display name and application, distinguishing it from functions that list (`list_channel_tabs`) or modify (`update_channel_tab`) existing tabs.
+        Pin a message in a chat.
 
         Args:
-            team_id (string): team-id
-            channel_id (string): channel-id
-            id (string): The unique identifier for an entity. Read-only.
-            configuration (object): configuration
-            displayName (string): Name of the tab.
-            webUrl (string): Deep link URL of the tab instance. Read only.
-            teamsApp (string): teamsApp
+            chat_id (string): The unique identifier of the chat.
+            message_id (string): The unique identifier of the message to pin.
 
         Returns:
-            Any: Created navigation property.
+            dict[str, Any]: A dictionary containing the API response for the pinned message.
 
         Raises:
-            HTTPStatusError: Raised when the API request fails with detailed error information including status code and response body.
+            HTTPStatusError: If the API request fails.
 
         Tags:
-            teams.channel
+            teams.chat, pinned_message, create, pin
         """
-        if team_id is None:
-            raise ValueError("Missing required parameter 'team-id'.")
-        if channel_id is None:
-            raise ValueError("Missing required parameter 'channel-id'.")
-        request_body_data = None
-        request_body_data = {
-            "id": id,
-            "configuration": configuration,
-            "displayName": displayName,
-            "webUrl": webUrl,
-            "teamsApp": teamsApp,
-        }
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
+        if chat_id is None:
+            raise ValueError("Missing required parameter 'chat-id'.")
+        if message_id is None:
+            raise ValueError("Missing required parameter 'message-id'.")
+
+        url = f"{self.base_url}/chats/{chat_id}/pinnedMessages"
+        
+        # The API requires a specific OData bind format for the message
+        payload = {
+            "message@odata.bind": f"https://graph.microsoft.com/v1.0/chats/{chat_id}/messages/{message_id}"
         }
-        url = f"{self.base_url}/teams/{team_id}/channels/{channel_id}/tabs"
-        query_params = {}
-        response = self._post(
-            url,
-            data=request_body_data,
-            params=query_params,
-            content_type="application/json",
-        )
+
+        response = await self._apost(url, data=payload)
         return self._handle_response(response)
 
-    def get_channel_tab_details(
+    async def unpin_chat_message(
         self,
-        team_id: str,
-        channel_id: str,
-        teamsTab_id: str,
-        select: list[str] | None = None,
-        expand: list[str] | None = None,
-    ) -> Any:
+        chat_id: str,
+        pinned_chat_message_id: str,
+    ) -> dict[str, Any]:
         """
-        Fetches properties for a single tab within a specific Microsoft Teams channel, identified by its team, channel, and tab IDs. Unlike `list_channel_tabs` which gets all tabs, this targets a specific one, with options to select fields or expand related entities in the response.
+        Unpin a message from a chat.
 
         Args:
-            team_id (string): team-id
-            channel_id (string): channel-id
-            teamsTab_id (string): teamsTab-id
-            select (array): Select properties to be returned
-            expand (array): Expand related entities
+            chat_id (string): The unique identifier of the chat.
+            pinned_chat_message_id (string): The unique identifier of the pinned message (not the message ID itself).
 
         Returns:
-            Any: Retrieved navigation property
+            dict[str, Any]: A dictionary containing the API response (usually empty for 204).
 
         Raises:
-            HTTPStatusError: Raised when the API request fails with detailed error information including status code and response body.
+            HTTPStatusError: If the API request fails.
 
         Tags:
-            teams.channel
+            teams.chat, pinned_message, delete, unpin
         """
-        if team_id is None:
-            raise ValueError("Missing required parameter 'team-id'.")
-        if channel_id is None:
-            raise ValueError("Missing required parameter 'channel-id'.")
-        if teamsTab_id is None:
-            raise ValueError("Missing required parameter 'teamsTab-id'.")
-        url = (
-            f"{self.base_url}/teams/{team_id}/channels/{channel_id}/tabs/{teamsTab_id}"
-        )
-        query_params = {
-            k: v for k, v in [("$select", select), ("$expand", expand)] if v is not None
-        }
-        response = self._get(url, params=query_params)
+        if chat_id is None:
+            raise ValueError("Missing required parameter 'chat-id'.")
+        if pinned_chat_message_id is None:
+            raise ValueError("Missing required parameter 'pinned-chat-message-id'.")
+
+        url = f"{self.base_url}/chats/{chat_id}/pinnedMessages/{pinned_chat_message_id}"
+        
+        response = await self._adelete(url)
+        # DELETE 204 returns no content, handle gracefully
+        if response.status_code == 204:
+            return {"status": "success", "message": "Message unpinned successfully."}
         return self._handle_response(response)
 
-    def update_channel_tab(
+# Teams 
+
+    async def create_team(
         self,
-        team_id: str,
-        channel_id: str,
-        teamsTab_id: str,
-        id: str | None = None,
-        configuration: dict[str, dict[str, Any]] | None = None,
-        displayName: str | None = None,
-        webUrl: str | None = None,
-        teamsApp: Any | None = None,
-    ) -> Any:
+        display_name: str,
+        description: str,
+    ) -> dict[str, Any]:
         """
-        Modifies properties of an existing tab within a specific Microsoft Teams channel. It uses the team, channel, and tab IDs to target the tab, allowing for partial updates to its configuration or display name via a PATCH request, differentiating it from tab creation or deletion functions.
+        Create a new team.
+        Uses the 'standard' template by default.
 
         Args:
-            team_id (string): team-id
-            channel_id (string): channel-id
-            teamsTab_id (string): teamsTab-id
-            id (string): The unique identifier for an entity. Read-only.
-            configuration (object): configuration
-            displayName (string): Name of the tab.
-            webUrl (string): Deep link URL of the tab instance. Read only.
-            teamsApp (string): teamsApp
+            display_name (string): The name of the team.
+            description (string): The description of the team.
 
         Returns:
-            Any: Success
+            dict[str, Any]: A dictionary containing the API response (e.g., location header for the async operation).
 
         Raises:
-            HTTPStatusError: Raised when the API request fails with detailed error information including status code and response body.
+            HTTPStatusError: If the API request fails.
 
         Tags:
-            teams.channel
-        """
-        if team_id is None:
-            raise ValueError("Missing required parameter 'team-id'.")
-        if channel_id is None:
-            raise ValueError("Missing required parameter 'channel-id'.")
-        if teamsTab_id is None:
-            raise ValueError("Missing required parameter 'teamsTab-id'.")
-        request_body_data = None
-        request_body_data = {
-            "id": id,
-            "configuration": configuration,
-            "displayName": displayName,
-            "webUrl": webUrl,
-            "teamsApp": teamsApp,
-        }
-        request_body_data = {
-            k: v for k, v in request_body_data.items() if v is not None
-        }
-        url = (
-            f"{self.base_url}/teams/{team_id}/channels/{channel_id}/tabs/{teamsTab_id}"
-        )
-        query_params = {}
-        response = self._patch(url, data=request_body_data, params=query_params)
-        return self._handle_response(response)
-
-    def delete_channel_tab(
-        self, team_id: str, channel_id: str, teamsTab_id: str
-    ) -> Any:
+            teams.team, create, provision
         """
-        Permanently removes a specific tab from a Microsoft Teams channel using its unique ID, along with the parent team and channel IDs. This function is the destructive counterpart to `create_channel_tab`, designed to delete a tab rather than create, list, or update one.
-
-        Args:
-            team_id (string): team-id
-            channel_id (string): channel-id
-            teamsTab_id (string): teamsTab-id
-
-        Returns:
-            Any: Success
-
-        Raises:
-            HTTPStatusError: Raised when the API request fails with detailed error information including status code and response body.
+        if display_name is None:
+            raise ValueError("Missing required parameter 'display-name'.")
+        if description is None:
+            raise ValueError("Missing required parameter 'description'.")
 
-        Tags:
-            teams.channel
-        """
-        if team_id is None:
-            raise ValueError("Missing required parameter 'team-id'.")
-        if channel_id is None:
-            raise ValueError("Missing required parameter 'channel-id'.")
-        if teamsTab_id is None:
-            raise ValueError("Missing required parameter 'teamsTab-id'.")
-        url = (
-            f"{self.base_url}/teams/{team_id}/channels/{channel_id}/tabs/{teamsTab_id}"
-        )
-        query_params = {}
-        response = self._delete(url, params=query_params)
+        url = f"{self.base_url}/teams"
+        
+        payload = {
+            "template@odata.bind": "https://graph.microsoft.com/v1.0/teamsTemplates('standard')",
+            "displayName": display_name,
+            "description": description
+        }
+
+        response = await self._apost(url, data=payload)
+        
+        # 202 Accepted means it's an async operation. 
+        # The Location header contains the URL to check status.
+        if response.status_code == 202:
+            return {
+                "status": "accepted", 
+                "operation_location": response.headers.get("Location"),
+                "message": "Team creation initiated. Check operation_location for status."
+            }
+            
         return self._handle_response(response)
 
-    def get_primary_team_channel(
+    async def get_team(
         self,
         team_id: str,
         select: list[str] | None = None,
         expand: list[str] | None = None,
-    ) -> Any:
+    ) -> dict[str, Any]:
         """
-        Retrieves the primary channel (usually 'General') for a specified team using its ID. Unlike `get_channel_details`, this function directly accesses the team's default channel without requiring a specific channel ID. Optional parameters can select or expand properties in the returned data.
+        Retrieve a specific team's details.
+        Supported OData parameters:
+        - $select: Select specific properties.
+        - $expand: Expand related entities.
 
         Args:
-            team_id (string): team-id
-            select (array): Select properties to be returned
-            expand (array): Expand related entities
+            team_id (string): The unique identifier of the team.
+            select (array): Select specific properties.
+            expand (array): Expand related entities.
 
         Returns:
-            Any: Retrieved navigation property
+            dict[str, Any]: The team resource.
 
         Raises:
-            HTTPStatusError: Raised when the API request fails with detailed error information including status code and response body.
+            HTTPStatusError: If the API request fails.
 
         Tags:
-            teams.channel
+            teams.team, read, get
         """
         if team_id is None:
             raise ValueError("Missing required parameter 'team-id'.")
-        url = f"{self.base_url}/teams/{team_id}/primaryChannel"
+
+        url = f"{self.base_url}/teams/{team_id}"
+
+        # Helper to format list params
+        def fmt(val):
+            return ",".join(val) if isinstance(val, list) else val
+
         query_params = {
-            k: v for k, v in [("$select", select), ("$expand", expand)] if v is not None
+            k: fmt(v)
+            for k, v in [
+                ("$select", select),
+                ("$expand", expand),
+            ]
+            if v is not None
         }
-        response = self._get(url, params=query_params)
+
+        response = await self._aget(url, params=query_params)
         return self._handle_response(response)
 
-    def list_user_installed_apps(
+    async def list_joined_teams(
         self,
-        user_id: str,
-        top: int | None = None,
-        skip: int | None = None,
-        search: str | None = None,
-        filter: str | None = None,
-        count: bool | None = None,
-        orderby: list[str] | None = None,
-        select: list[str] | None = None,
-        expand: list[str] | None = None,
     ) -> dict[str, Any]:
         """
-        Retrieves applications installed in a user's personal Microsoft Teams scope, identified by their ID. Unlike `list_installed_chat_apps` which targets chat installations, this focuses on the user's scope. It supports optional OData parameters for filtering, sorting, and pagination to customize the returned app collection.
-
-        Args:
-            user_id (string): user-id
-            top (integer): Show only the first n items Example: '50'.
-            skip (integer): Skip the first n items
-            search (string): Search items by search phrases
-            filter (string): Filter items by property values
-            count (boolean): Include count of items
-            orderby (array): Order items by property values
-            select (array): Select properties to be returned
-            expand (array): Expand related entities
+        List the teams that the user is a direct member of.
+        Note: This endpoint does not support OData query parameters.
+        It returns a subset of properties (id, displayName, description, isArchived, tenantId) by default.
 
         Returns:
-            dict[str, Any]: Retrieved collection
+            dict[str, Any]: A dictionary containing the list of teams.
 
         Raises:
-            HTTPStatusError: Raised when the API request fails with detailed error information including status code and response body.
-
+            HTTPStatusError: If the API request fails.
+            
         Tags:
-            users.userTeamwork
+            teams.team, list, read, joined
         """
-        if user_id is None:
-            raise ValueError("Missing required parameter 'user-id'.")
-        url = f"{self.base_url}/users/{user_id}/teamwork/installedApps"
-        query_params = {
-            k: v
-            for k, v in [
-                ("$top", top),
-                ("$skip", skip),
-                ("$search", search),
-                ("$filter", filter),
-                ("$count", count),
-                ("$orderby", orderby),
-                ("$select", select),
-                ("$expand", expand),
-            ]
-            if v is not None
-        }
-        response = self._get(url, params=query_params)
+        url = f"{self.base_url}/me/joinedTeams"
+
+        response = await self._aget(url)
         return self._handle_response(response)
 
     def list_tools(self):
         return [
+            self.get_me,
             self.get_user_chats,
-            self.get_joined_teams,
-            self.list_channels_for_team,
-            self.send_chat_message,
-            self.send_channel_message,
-            self.reply_to_channel_message,
             self.create_chat,
             self.get_chat_details,
             self.update_chat_details,
-            self.list_installed_chat_apps,
             self.list_chat_members,
-            self.add_member_to_chat,
             self.get_chat_member,
-            self.delete_chat_member,
             self.list_chat_messages,
             self.get_chat_message,
-            self.list_chat_message_replies,
-            self.reply_to_chat_message,
-            self.get_chat_reply_details,
-            self.create_team_from_group,
+            self.send_chat_message,
+            self.list_all_channels,
+            self.get_channel,
+            self.get_primary_channel,
+            self.send_channel_message,
+            self.reply_to_channel_message,
+            self.list_pinned_chat_messages,
+            self.pin_chat_message,
+            self.unpin_chat_message,
             self.create_team,
-            self.get_channel_details,
-            self.update_channel_message,
-            self.update_channel_message_reply,
-            self.list_channel_tabs,
-            self.create_channel_tab,
-            self.get_channel_tab_details,
-            self.update_channel_tab,
-            self.delete_channel_tab,
-            self.get_primary_team_channel,
-            self.list_user_installed_apps,
+            self.get_team,
+            self.list_joined_teams,
         ]