lex-microsoft_teams 0.6.45 → 0.6.47

data/lib/legion/extensions/microsoft_teams/runners/channel_messages.rb

@@ -9,17 +9,56 @@ module Legion
         module ChannelMessages
           include Legion::Extensions::MicrosoftTeams::Helpers::Client
 
+          def self.trigger_words
+            %w[post posts feed thread reply]
+          end
+
+          definition :list_channel_messages,
+                     desc:          'List messages posted in a Teams channel',
+                     mcp_prefix:    'teams.list_channel_messages',
+                     mcp_category:  'teams_channel_messages',
+                     mcp_tier:      :standard,
+                     idempotent:    true,
+                     inputs:        { properties: { team_id:    { type: 'string' },
+                                                    channel_id: { type: 'string' } },
+                                      required:   %w[team_id channel_id] },
+                     trigger_words: %w[channel history posts feed]
+
           def list_channel_messages(team_id:, channel_id:, top: 50, **)
             params = { '$top' => top }
             response = graph_connection(**).get("teams/#{team_id}/channels/#{channel_id}/messages", params)
             { result: response.body }
           end
 
+          definition :get_channel_message,
+                     desc:          'Get a specific message from a Teams channel',
+                     mcp_prefix:    'teams.get_channel_message',
+                     mcp_category:  'teams_channel_messages',
+                     mcp_tier:      :standard,
+                     idempotent:    true,
+                     inputs:        { properties: { team_id:    { type: 'string' },
+                                                    channel_id: { type: 'string' },
+                                                    message_id: { type: 'string' } },
+                                      required:   %w[team_id channel_id message_id] },
+                     trigger_words: %w[message fetch]
+
           def get_channel_message(team_id:, channel_id:, message_id:, **)
             response = graph_connection(**).get("teams/#{team_id}/channels/#{channel_id}/messages/#{message_id}")
             { result: response.body }
           end
 
+          definition :send_channel_message,
+                     desc:          'Post a message to a Teams channel',
+                     mcp_prefix:    'teams.send_channel_message',
+                     mcp_category:  'teams_channel_messages',
+                     mcp_tier:      :elevated,
+                     idempotent:    false,
+                     inputs:        { properties: { team_id:    { type: 'string' },
+                                                    channel_id: { type: 'string' },
+                                                    content:    { type: 'string' } },
+                                      required:   %w[team_id channel_id content] },
+                     trigger_words: %w[post send write]
+
           def send_channel_message(team_id:, channel_id:, content:, content_type: 'text', attachments: [], **)
             payload = { body: { contentType: content_type, content: content } }
             payload[:attachments] = attachments unless attachments.empty?
@@ -27,6 +66,19 @@ module Legion
             { result: response.body }
           end
 
+          definition :reply_to_channel_message,
+                     desc:          'Reply to a thread in a Teams channel',
+                     mcp_prefix:    'teams.reply_to_channel_message',
+                     mcp_category:  'teams_channel_messages',
+                     mcp_tier:      :elevated,
+                     idempotent:    false,
+                     inputs:        { properties: { team_id:    { type: 'string' },
+                                                    channel_id: { type: 'string' },
+                                                    message_id: { type: 'string' },
+                                                    content:    { type: 'string' } },
+                                      required:   %w[team_id channel_id message_id content] },
+                     trigger_words: %w[reply respond]
+
           def reply_to_channel_message(team_id:, channel_id:, message_id:, content:, content_type: 'text', **)
             payload = { body: { contentType: content_type, content: content } }
             response = graph_connection(**).post(
@@ -35,6 +87,18 @@ module Legion
             { result: response.body }
           end
 
+          definition :list_channel_message_replies,
+                     desc:          'List replies in a Teams channel message thread',
+                     mcp_prefix:    'teams.list_channel_message_replies',
+                     mcp_category:  'teams_channel_messages',
+                     mcp_tier:      :standard,
+                     idempotent:    true,
+                     inputs:        { properties: { team_id:    { type: 'string' },
+                                                    channel_id: { type: 'string' },
+                                                    message_id: { type: 'string' } },
+                                      required:   %w[team_id channel_id message_id] },
+                     trigger_words: %w[replies thread]
+
           def list_channel_message_replies(team_id:, channel_id:, message_id:, top: 50, **)
             params = { '$top' => top }
             response = graph_connection(**).get(
@@ -43,6 +107,27 @@ module Legion
             { result: response.body }
           end
 
+          definition :edit_channel_message,
+                     desc:          'Edit an existing message in a Teams channel',
+                     mcp_prefix:    'teams.edit_channel_message',
+                     mcp_category:  'teams_channel_messages',
+                     mcp_tier:      :elevated,
+                     idempotent:    false,
+                     inputs:        { properties: { team_id:    { type: 'string' },
+                                                    channel_id: { type: 'string' },
+                                                    message_id: { type: 'string' },
+                                                    content:    { type: 'string' } },
+                                      required:   %w[team_id channel_id message_id content] },
+                     trigger_words: %w[edit update]
+
+          def edit_channel_message(team_id:, channel_id:, message_id:, content:, content_type: 'text', **)
+            payload = { body: { contentType: content_type, content: content } }
+            response = graph_connection(**).patch(
+              "teams/#{team_id}/channels/#{channel_id}/messages/#{message_id}", payload
+            )
+            { result: response.body }
+          end
+
           include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers, false) &&
                                                       Legion::Extensions::Helpers.const_defined?(:Lex, false)
         end

data/lib/legion/extensions/microsoft_teams/runners/channels.rb

@@ -7,18 +7,54 @@ module Legion
     module MicrosoftTeams
       module Runners
         module Channels
+          extend Legion::Extensions::Definitions
           include Legion::Extensions::MicrosoftTeams::Helpers::Client
 
+          def self.trigger_words
+            %w[channel channels post posts feed]
+          end
+
+          definition :list_channels,
+                     desc:          'List channels in a Team',
+                     mcp_prefix:    'teams.list_channels',
+                     mcp_category:  'teams_channels',
+                     mcp_tier:      :low,
+                     idempotent:    true,
+                     inputs:        { properties: { team_id: { type: 'string' } }, required: ['team_id'] },
+                     trigger_words: %w[channels list]
+
           def list_channels(team_id:, **)
             response = graph_connection(**).get("teams/#{team_id}/channels")
             { result: response.body }
           end
 
+          definition :get_channel,
+                     desc:          'Get a specific channel in a Team',
+                     mcp_prefix:    'teams.get_channel',
+                     mcp_category:  'teams_channels',
+                     mcp_tier:      :low,
+                     idempotent:    true,
+                     inputs:        { properties: { team_id:    { type: 'string' },
+                                                    channel_id: { type: 'string' } },
+                                      required:   %w[team_id channel_id] },
+                     trigger_words: %w[channel details]
+
           def get_channel(team_id:, channel_id:, **)
             response = graph_connection(**).get("teams/#{team_id}/channels/#{channel_id}")
             { result: response.body }
           end
 
+          definition :create_channel,
+                     desc:          'Create a new channel in a Team',
+                     mcp_prefix:    'teams.create_channel',
+                     mcp_category:  'teams_channels',
+                     mcp_tier:      :elevated,
+                     idempotent:    false,
+                     inputs:        { properties: { team_id:      { type: 'string' },
+                                                    display_name: { type: 'string' } },
+                                      required:   %w[team_id display_name] },
+                     trigger_words: %w[create channel]
+
           def create_channel(team_id:, display_name:, description: nil, membership_type: 'standard', **)
             payload = { displayName: display_name, membershipType: membership_type }
             payload[:description] = description if description
@@ -26,6 +62,17 @@ module Legion
             { result: response.body }
           end
 
+          definition :update_channel,
+                     desc:          'Update a channel display name or description',
+                     mcp_prefix:    'teams.update_channel',
+                     mcp_category:  'teams_channels',
+                     mcp_tier:      :elevated,
+                     idempotent:    false,
+                     inputs:        { properties: { team_id:    { type: 'string' },
+                                                    channel_id: { type: 'string' } },
+                                      required:   %w[team_id channel_id] },
+                     trigger_words: %w[update rename]
+
           def update_channel(team_id:, channel_id:, display_name: nil, description: nil, **)
             payload = {}
             payload[:displayName] = display_name if display_name
@@ -34,11 +81,33 @@ module Legion
             { result: response.body }
           end
 
+          definition :delete_channel,
+                     desc:          'Delete a channel from a Team',
+                     mcp_prefix:    'teams.delete_channel',
+                     mcp_category:  'teams_channels',
+                     mcp_tier:      :high,
+                     idempotent:    false,
+                     inputs:        { properties: { team_id:    { type: 'string' },
+                                                    channel_id: { type: 'string' } },
+                                      required:   %w[team_id channel_id] },
+                     trigger_words: %w[delete remove]
+
           def delete_channel(team_id:, channel_id:, **)
             response = graph_connection(**).delete("teams/#{team_id}/channels/#{channel_id}")
             { result: response.body }
           end
 
+          definition :list_channel_members,
+                     desc:          'List members of a channel',
+                     mcp_prefix:    'teams.list_channel_members',
+                     mcp_category:  'teams_channels',
+                     mcp_tier:      :standard,
+                     idempotent:    true,
+                     inputs:        { properties: { team_id:    { type: 'string' },
+                                                    channel_id: { type: 'string' } },
+                                      required:   %w[team_id channel_id] },
+                     trigger_words: %w[members roster]
+
           def list_channel_members(team_id:, channel_id:, **)
             response = graph_connection(**).get("teams/#{team_id}/channels/#{channel_id}/members")
             { result: response.body }

data/lib/legion/extensions/microsoft_teams/runners/chats.rb

@@ -7,19 +7,56 @@ module Legion
     module MicrosoftTeams
       module Runners
         module Chats
+          extend Legion::Extensions::Definitions
           include Legion::Extensions::MicrosoftTeams::Helpers::Client
 
+          def self.trigger_words
+            %w[chat chats conversation conversations dm direct]
+          end
+
+          definition :list_chats,
+                     desc:          'List Teams chats for the current user',
+                     mcp_prefix:    'teams.list_chats',
+                     mcp_category:  'teams_chat',
+                     mcp_tier:      :standard,
+                     idempotent:    true,
+                     trigger_words: %w[chats conversations]
+
           def list_chats(user_id: 'me', top: 50, **)
             params = { '$top' => top }
             response = graph_connection(**).get("#{user_path(user_id)}/chats", params)
             { result: response.body }
           end
 
+          definition :get_chat,
+                     desc:          'Get metadata for a specific Teams chat by ID',
+                     mcp_prefix:    'teams.get_chat',
+                     mcp_category:  'teams_chat',
+                     mcp_tier:      :standard,
+                     idempotent:    true,
+                     inputs:        { properties: { chat_id: { type:        'string',
+                                                               description: 'The Teams chat ID (19:...@thread.v2)' } },
+                                      required:   ['chat_id'] },
+                     trigger_words: %w[chat details]
+
           def get_chat(chat_id:, **)
             response = graph_connection(**).get("chats/#{chat_id}")
             { result: response.body }
           end
 
+          definition :create_chat,
+                     desc:          'Create a new 1:1 or group Teams chat',
+                     mcp_prefix:    'teams.create_chat',
+                     mcp_category:  'teams_chat',
+                     mcp_tier:      :elevated,
+                     idempotent:    false,
+                     inputs:        { properties: { members:   { type:        'array',
+                                                                 description: 'Array of user IDs or UPNs' },
+                                                    chat_type: { type:        'string',
+                                                                 description: 'oneOnOne or group' } },
+                                      required:   ['members'] },
+                     trigger_words: %w[create conversation start]
+
           def create_chat(members:, chat_type: 'oneOnOne', topic: nil, **)
             payload = { chatType: chat_type, members: members }
             payload[:topic] = topic if topic
@@ -27,11 +64,31 @@ module Legion
             { result: response.body }
           end
 
+          definition :list_chat_members,
+                     desc:          'List members of a Teams chat',
+                     mcp_prefix:    'teams.list_chat_members',
+                     mcp_category:  'teams_chat',
+                     mcp_tier:      :standard,
+                     idempotent:    true,
+                     inputs:        { properties: { chat_id: { type: 'string' } }, required: ['chat_id'] },
+                     trigger_words: %w[members participants]
+
           def list_chat_members(chat_id:, **)
             response = graph_connection(**).get("chats/#{chat_id}/members")
             { result: response.body }
           end
 
+          definition :add_chat_member,
+                     desc:          'Add a member to a Teams chat',
+                     mcp_prefix:    'teams.add_chat_member',
+                     mcp_category:  'teams_chat',
+                     mcp_tier:      :elevated,
+                     idempotent:    false,
+                     inputs:        { properties: { chat_id: { type: 'string' },
+                                                    user_id: { type: 'string' } },
+                                      required:   %w[chat_id user_id] },
+                     trigger_words: %w[invite add member]
+
           def add_chat_member(chat_id:, user_id:, roles: ['owner'], **)
             payload = {
               '@odata.type'     => '#microsoft.graph.aadUserConversationMember',

data/lib/legion/extensions/microsoft_teams/runners/files.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/microsoft_teams/helpers/client'
+
+module Legion
+  module Extensions
+    module MicrosoftTeams
+      module Runners
+        module Files
+          include Legion::Extensions::MicrosoftTeams::Helpers::Client
+
+          def self.trigger_words
+            %w[file files drive onedrive sharepoint document documents]
+          end
+
+          definition :list_drive_items,
+                     desc:          'List files in the root of a user\'s OneDrive',
+                     mcp_prefix:    'teams.list_drive_items',
+                     mcp_category:  'teams_files',
+                     mcp_tier:      :standard,
+                     idempotent:    true,
+                     trigger_words: %w[files drive onedrive]
+
+          def list_drive_items(user_id: 'me', **)
+            response = graph_connection(**).get("#{user_path(user_id)}/drive/root/children")
+            { result: response.body }
+          end
+
+          definition :get_drive_item,
+                     desc:          'Get metadata for a specific OneDrive file or folder',
+                     mcp_prefix:    'teams.get_drive_item',
+                     mcp_category:  'teams_files',
+                     mcp_tier:      :standard,
+                     idempotent:    true,
+                     inputs:        { properties: { item_id: { type: 'string' } }, required: ['item_id'] },
+                     trigger_words: %w[file item]
+
+          def get_drive_item(item_id:, user_id: 'me', **)
+            response = graph_connection(**).get("#{user_path(user_id)}/drive/items/#{item_id}")
+            { result: response.body }
+          end
+
+          definition :get_drive_item_content,
+                     desc:          'Download the content of a OneDrive file',
+                     mcp_prefix:    'teams.get_drive_item_content',
+                     mcp_category:  'teams_files',
+                     mcp_tier:      :standard,
+                     idempotent:    true,
+                     inputs:        { properties: { item_id: { type: 'string' } }, required: ['item_id'] },
+                     trigger_words: %w[download content read]
+
+          def get_drive_item_content(item_id:, user_id: 'me', **)
+            response = graph_connection(**).get("#{user_path(user_id)}/drive/items/#{item_id}/content")
+            { result: response.body }
+          end
+
+          definition :list_team_drive_items,
+                     desc:          'List files in a Team\'s SharePoint document library',
+                     mcp_prefix:    'teams.list_team_drive_items',
+                     mcp_category:  'teams_files',
+                     mcp_tier:      :standard,
+                     idempotent:    true,
+                     inputs:        { properties: { team_id: { type: 'string' } }, required: ['team_id'] },
+                     trigger_words: %w[sharepoint documents team]
+
+          def list_team_drive_items(team_id:, **)
+            response = graph_connection(**).get("teams/#{team_id}/drive/root/children")
+            { result: response.body }
+          end
+
+          include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers, false) &&
+                                                      Legion::Extensions::Helpers.const_defined?(:Lex, false)
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/microsoft_teams/runners/local_cache.rb

@@ -7,6 +7,10 @@ module Legion
     module MicrosoftTeams
       module Runners
         module LocalCache
+          definition :extract_local_messages, mcp_exposed: false
+          definition :local_cache_available?, mcp_exposed: false
+          definition :local_cache_stats, mcp_exposed: false
+
           # Extract messages from the local Teams LevelDB cache.
           # Works offline without Graph API credentials.
           def extract_local_messages(db_path: nil, since: nil, channels: nil, senders: nil, skip_bots: true, **)

data/lib/legion/extensions/microsoft_teams/runners/loop.rb

@@ -8,9 +8,15 @@ module Legion
     module MicrosoftTeams
       module Runners
         module Loop
+          extend Legion::Extensions::Definitions
           include Legion::Extensions::MicrosoftTeams::Helpers::Client
           include Legion::JSON::Helper
 
+          definition :create_loop_file, mcp_exposed: false
+          definition :loop_attachment, mcp_exposed: false
+          definition :post_loop_to_chat, mcp_exposed: false
+          definition :post_loop_to_channel, mcp_exposed: false
+
           # Creates a new .loop file in the user's OneDrive via the Graph API.
           # The Fluid Framework collaborative session is initialized by Teams on first open.
           # Returns the drive item metadata including +webUrl+, which can be passed to

data/lib/legion/extensions/microsoft_teams/runners/meeting_artifacts.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/microsoft_teams/helpers/client'
+
+module Legion
+  module Extensions
+    module MicrosoftTeams
+      module Runners
+        module MeetingArtifacts
+          include Legion::Extensions::MicrosoftTeams::Helpers::Client
+
+          def self.trigger_words
+            %w[recording recordings whiteboard artifact artifacts]
+          end
+
+          definition :list_meeting_artifacts,
+                     desc:          'List artifacts (recordings, whiteboards) for an online meeting',
+                     mcp_prefix:    'teams.list_meeting_artifacts',
+                     mcp_category:  'teams_meetings',
+                     mcp_tier:      :standard,
+                     idempotent:    true,
+                     inputs:        { properties: { meeting_id: { type: 'string' } }, required: ['meeting_id'] },
+                     trigger_words: %w[artifacts recordings whiteboards]
+
+          def list_meeting_artifacts(meeting_id:, user_id: 'me', **)
+            response = graph_connection(**).get("#{user_path(user_id)}/onlineMeetings/#{meeting_id}/artifacts")
+            { result: response.body }
+          end
+
+          definition :get_meeting_artifact,
+                     desc:          'Get a specific artifact from an online meeting',
+                     mcp_prefix:    'teams.get_meeting_artifact',
+                     mcp_category:  'teams_meetings',
+                     mcp_tier:      :standard,
+                     idempotent:    true,
+                     inputs:        { properties: { meeting_id:  { type: 'string' },
+                                                    artifact_id: { type: 'string' } },
+                                      required:   %w[meeting_id artifact_id] },
+                     trigger_words: %w[artifact recording whiteboard download]
+
+          def get_meeting_artifact(meeting_id:, artifact_id:, user_id: 'me', **)
+            response = graph_connection(**).get(
+              "#{user_path(user_id)}/onlineMeetings/#{meeting_id}/artifacts/#{artifact_id}"
+            )
+            { result: response.body }
+          end
+
+          include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers, false) &&
+                                                      Legion::Extensions::Helpers.const_defined?(:Lex, false)
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/microsoft_teams/runners/meetings.rb

@@ -9,16 +9,51 @@ module Legion
         module Meetings
           include Legion::Extensions::MicrosoftTeams::Helpers::Client
 
+          def self.trigger_words
+            %w[meeting meetings calendar schedule scheduled attendance attendee]
+          end
+
+          definition :list_meetings,
+                     desc:          'List online meetings for the current user',
+                     mcp_prefix:    'teams.list_meetings',
+                     mcp_category:  'teams_meetings',
+                     mcp_tier:      :low,
+                     idempotent:    true,
+                     trigger_words: %w[meetings upcoming calendar]
+
           def list_meetings(user_id: 'me', **)
             response = graph_connection(**).get("#{user_path(user_id)}/onlineMeetings")
             { result: response.body }
           end
 
+          definition :get_meeting,
+                     desc:          'Get details for a specific online meeting',
+                     mcp_prefix:    'teams.get_meeting',
+                     mcp_category:  'teams_meetings',
+                     mcp_tier:      :low,
+                     idempotent:    true,
+                     inputs:        { properties: { meeting_id: { type: 'string' } }, required: ['meeting_id'] },
+                     trigger_words: %w[meeting details]
+
           def get_meeting(meeting_id:, user_id: 'me', **)
             response = graph_connection(**).get("#{user_path(user_id)}/onlineMeetings/#{meeting_id}")
             { result: response.body }
           end
 
+          definition :create_meeting,
+                     desc:          'Create a new online meeting',
+                     mcp_prefix:    'teams.create_meeting',
+                     mcp_category:  'teams_meetings',
+                     mcp_tier:      :elevated,
+                     idempotent:    false,
+                     inputs:        { properties: { subject:    { type: 'string' },
+                                                    start_time: { type:        'string',
+                                                                  description: 'ISO 8601 start datetime' },
+                                                    end_time:   { type:        'string',
+                                                                  description: 'ISO 8601 end datetime' } },
+                                      required:   %w[subject start_time end_time] },
+                     trigger_words: %w[create schedule]
+
           def create_meeting(subject:, start_time:, end_time:, user_id: 'me', **)
             payload = {
               subject:       subject,
@@ -29,6 +64,15 @@ module Legion
             { result: response.body }
           end
 
+          definition :update_meeting,
+                     desc:          'Update an existing online meeting',
+                     mcp_prefix:    'teams.update_meeting',
+                     mcp_category:  'teams_meetings',
+                     mcp_tier:      :elevated,
+                     idempotent:    false,
+                     inputs:        { properties: { meeting_id: { type: 'string' } }, required: ['meeting_id'] },
+                     trigger_words: %w[update reschedule]
+
           def update_meeting(meeting_id:, user_id: 'me', subject: nil, start_time: nil, end_time: nil, **)
             payload = {}
             payload[:subject] = subject if subject
@@ -38,27 +82,75 @@ module Legion
             { result: response.body }
           end
 
+          definition :delete_meeting,
+                     desc:          'Delete an online meeting',
+                     mcp_prefix:    'teams.delete_meeting',
+                     mcp_category:  'teams_meetings',
+                     mcp_tier:      :high,
+                     idempotent:    false,
+                     inputs:        { properties: { meeting_id: { type: 'string' } }, required: ['meeting_id'] },
+                     trigger_words: %w[delete cancel]
+
           def delete_meeting(meeting_id:, user_id: 'me', **)
             response = graph_connection(**).delete("#{user_path(user_id)}/onlineMeetings/#{meeting_id}")
             { result: response.body }
           end
 
+          definition :get_meeting_by_join_url,
+                     desc:          'Look up a meeting by its join URL',
+                     mcp_prefix:    'teams.get_meeting_by_join_url',
+                     mcp_category:  'teams_meetings',
+                     mcp_tier:      :low,
+                     idempotent:    true,
+                     inputs:        { properties: { join_url: { type:        'string',
+                                                                description: 'Teams join URL' } },
+                                      required:   ['join_url'] },
+                     trigger_words: %w[url join find]
+
           def get_meeting_by_join_url(join_url:, user_id: 'me', **)
             params = { '$filter' => "joinWebUrl eq '#{join_url.gsub("'", "''")}'" }
             response = graph_connection(**).get("#{user_path(user_id)}/onlineMeetings", params)
             { result: response.body }
           end
 
+          definition :list_attendance_reports,
+                     desc:          'List attendance reports for an online meeting',
+                     mcp_prefix:    'teams.list_attendance_reports',
+                     mcp_category:  'teams_meetings',
+                     mcp_tier:      :standard,
+                     idempotent:    true,
+                     inputs:        { properties: { meeting_id: { type: 'string' } }, required: ['meeting_id'] },
+                     trigger_words: %w[attendance attendees report]
+
           def list_attendance_reports(meeting_id:, user_id: 'me', **)
             response = graph_connection(**).get("#{user_path(user_id)}/onlineMeetings/#{meeting_id}/attendanceReports")
             { result: response.body }
           end
 
+          definition :get_attendance_report,
+                     desc:          'Get a specific attendance report for an online meeting',
+                     mcp_prefix:    'teams.get_attendance_report',
+                     mcp_category:  'teams_meetings',
+                     mcp_tier:      :standard,
+                     idempotent:    true,
+                     inputs:        { properties: { meeting_id: { type: 'string' },
+                                                    report_id:  { type: 'string' } },
+                                      required:   %w[meeting_id report_id] },
+                     trigger_words: %w[attendance details]
+
           def get_attendance_report(meeting_id:, report_id:, user_id: 'me', **)
             response = graph_connection(**).get("#{user_path(user_id)}/onlineMeetings/#{meeting_id}/attendanceReports/#{report_id}")
             { result: response.body }
           end
 
+          definition :resolve_meeting,
+                     desc:          'Resolve a Teams meeting from a chat thread ID or join URL',
+                     mcp_prefix:    'teams.resolve_meeting',
+                     mcp_category:  'teams_meetings',
+                     mcp_tier:      :low,
+                     idempotent:    true,
+                     trigger_words: %w[resolve find]
+
           def resolve_meeting(chat_thread_id: nil, join_url: nil, user_id: 'me', **)
             return { error: 'provide chat_thread_id or join_url' } unless chat_thread_id || join_url