lex-microsoft_teams 0.6.45 → 0.6.47

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

@@ -7,19 +7,58 @@ module Legion
     module MicrosoftTeams
       module Runners
         module Messages
+          extend Legion::Extensions::Definitions
           include Legion::Extensions::MicrosoftTeams::Helpers::Client
 
+          def self.trigger_words
+            %w[message messages reply replies thread send]
+          end
+
+          definition :list_chat_messages,
+                     desc:          'List messages in a Teams chat thread',
+                     mcp_prefix:    'teams.list_chat_messages',
+                     mcp_category:  'teams_messages',
+                     mcp_tier:      :standard,
+                     idempotent:    true,
+                     inputs:        { properties: { chat_id: { type:        'string',
+                                                               description: 'Teams chat ID' } },
+                                      required:   ['chat_id'] },
+                     trigger_words: %w[messages history read]
+
           def list_chat_messages(chat_id:, top: 50, **)
             params = { '$top' => top }
             response = graph_connection(**).get("chats/#{chat_id}/messages", params)
             { result: response.body }
           end
 
+          definition :get_chat_message,
+                     desc:          'Get a specific message from a Teams chat',
+                     mcp_prefix:    'teams.get_chat_message',
+                     mcp_category:  'teams_messages',
+                     mcp_tier:      :standard,
+                     idempotent:    true,
+                     inputs:        { properties: { chat_id:    { type: 'string' },
+                                                    message_id: { type: 'string' } },
+                                      required:   %w[chat_id message_id] },
+                     trigger_words: %w[message fetch]
+
           def get_chat_message(chat_id:, message_id:, **)
             response = graph_connection(**).get("chats/#{chat_id}/messages/#{message_id}")
             { result: response.body }
           end
 
+          definition :send_chat_message,
+                     desc:          'Send a message to a Teams chat',
+                     mcp_prefix:    'teams.send_chat_message',
+                     mcp_category:  'teams_messages',
+                     mcp_tier:      :elevated,
+                     idempotent:    false,
+                     inputs:        { properties: { chat_id: { type: 'string' },
+                                                    content: { type:        'string',
+                                                               description: 'Message text or HTML' } },
+                                      required:   %w[chat_id content] },
+                     trigger_words: %w[send post write]
+
           def send_chat_message(chat_id:, content:, content_type: 'text', attachments: [], **)
             payload = { body: { contentType: content_type, content: content } }
             payload[:attachments] = attachments unless attachments.empty?
@@ -27,12 +66,35 @@ module Legion
             { result: response.body }
           end
 
+          definition :reply_to_chat_message,
+                     desc:          'Reply to a message in a Teams chat',
+                     mcp_prefix:    'teams.reply_to_chat_message',
+                     mcp_category:  'teams_messages',
+                     mcp_tier:      :elevated,
+                     idempotent:    false,
+                     inputs:        { properties: { chat_id:    { type: 'string' },
+                                                    message_id: { type: 'string' },
+                                                    content:    { type: 'string' } },
+                                      required:   %w[chat_id message_id content] },
+                     trigger_words: %w[reply respond]
+
           def reply_to_chat_message(chat_id:, message_id:, content:, content_type: 'text', **)
             payload = { body: { contentType: content_type, content: content } }
             response = graph_connection(**).post("chats/#{chat_id}/messages/#{message_id}/replies", payload)
             { result: response.body }
           end
 
+          definition :list_message_replies,
+                     desc:          'List replies to a message in a Teams chat',
+                     mcp_prefix:    'teams.list_message_replies',
+                     mcp_category:  'teams_messages',
+                     mcp_tier:      :standard,
+                     idempotent:    true,
+                     inputs:        { properties: { chat_id:    { type: 'string' },
+                                                    message_id: { type: 'string' } },
+                                      required:   %w[chat_id message_id] },
+                     trigger_words: %w[replies thread]
+
           def list_message_replies(chat_id:, message_id:, top: 50, **)
             params = { '$top' => top }
             response = graph_connection(**).get("chats/#{chat_id}/messages/#{message_id}/replies", params)

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

@@ -13,7 +13,12 @@ module Legion
           TEAMS_SELECT = 'id,displayName,mail'
           OWNERS_SELECT = 'id,displayName,mail'
 
+          definition :sync_owners, mcp_exposed: false
+          definition :detect_orphans, mcp_exposed: false
+          definition :get_team_owners, mcp_exposed: false
+
           def sync_owners(team_id: nil, **)
+            log.debug("Ownership#sync_owners team_id=#{team_id.inspect}")
             conn = graph_connection(**)
             if team_id
               owners = fetch_owners(conn: conn, team_id: team_id)
@@ -26,10 +31,12 @@ module Legion
               { owners: all_owners, team_count: teams.length, synced_at: Time.now.utc.iso8601 }
             end
           rescue StandardError => e
+            handle_exception(e, level: :error, operation: 'Ownership#sync_owners', team_id: team_id)
             { error: e.message }
           end
 
           def detect_orphans(**)
+            log.debug('Ownership#detect_orphans')
             conn = graph_connection(**)
             teams = fetch_all_teams(conn: conn)
             orphaned = []
@@ -39,16 +46,20 @@ module Legion
               orphaned << { id: team['id'], display_name: team['displayName'], mail: team['mail'] } if owners.empty?
             end
 
+            log.info("Ownership#detect_orphans found #{orphaned.length}/#{teams.length} orphaned teams")
             { orphaned_teams: orphaned, total_scanned: teams.length, orphan_count: orphaned.length }
           rescue StandardError => e
+            handle_exception(e, level: :error, operation: 'Ownership#detect_orphans')
             { error: e.message }
           end
 
           def get_team_owners(team_id:, **)
+            log.debug("Ownership#get_team_owners team_id=#{team_id}")
             conn = graph_connection(**)
             owners = fetch_owners(conn: conn, team_id: team_id)
             { team_id: team_id, owners: owners }
           rescue StandardError => e
+            handle_exception(e, level: :error, operation: 'Ownership#get_team_owners', team_id: team_id)
             { error: e.message }
           end
 

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

@@ -7,20 +7,45 @@ module Legion
     module MicrosoftTeams
       module Runners
         module People
+          extend Legion::Extensions::Definitions
           include Legion::Extensions::MicrosoftTeams::Helpers::Client
 
+          def self.trigger_words
+            %w[profile people person colleague colleagues contact contacts]
+          end
+
+          definition :get_profile,
+                     desc:          'Get the Microsoft Graph profile for a user',
+                     mcp_prefix:    'teams.get_profile',
+                     mcp_category:  'teams_people',
+                     mcp_tier:      :low,
+                     idempotent:    true,
+                     trigger_words: %w[profile self]
+
           def get_profile(user_id: 'me', **)
+            log.debug("People#get_profile user_id=#{user_id}")
             response = graph_connection(**).get(user_path(user_id).to_s)
             { result: response.body }
           rescue StandardError => e
+            handle_exception(e, level: :error, operation: 'People#get_profile', user_id: user_id)
             { error: e.message }
           end
 
+          definition :list_people,
+                     desc:          'List people relevant to the current user (colleagues, contacts)',
+                     mcp_prefix:    'teams.list_people',
+                     mcp_category:  'teams_people',
+                     mcp_tier:      :standard,
+                     idempotent:    true,
+                     trigger_words: %w[people colleagues contacts]
+
           def list_people(user_id: 'me', top: 25, **)
+            log.debug("People#list_people user_id=#{user_id} top=#{top}")
             params = { '$top' => top }
             response = graph_connection(**).get("#{user_path(user_id)}/people", params)
             { result: response.body }
           rescue StandardError => e
+            handle_exception(e, level: :error, operation: 'People#list_people', user_id: user_id)
             { error: e.message }
           end
 

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

@@ -9,7 +9,20 @@ module Legion
         module Presence
           include Legion::Extensions::MicrosoftTeams::Helpers::Client
 
+          def self.trigger_words
+            %w[presence availability available status online busy away]
+          end
+
+          definition :get_presence,
+                     desc:          'Get the presence/availability status for a user',
+                     mcp_prefix:    'teams.get_presence',
+                     mcp_category:  'teams_presence',
+                     mcp_tier:      :low,
+                     idempotent:    true,
+                     trigger_words: %w[presence availability status online]
+
           def get_presence(user_id: 'me', **)
+            log.debug("Presence#get_presence user_id=#{user_id}")
             conn = graph_connection(**)
             response = conn.get("#{user_path(user_id)}/presence")
             body = response.body || {}
@@ -19,6 +32,7 @@ module Legion
               fetched_at:   Time.now.utc
             }
           rescue StandardError => e
+            handle_exception(e, level: :warn, operation: 'Presence#get_presence', user_id: user_id)
             { availability: 'Offline', activity: 'OffWork', error: e.message, fetched_at: Time.now.utc }
           end
 

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

@@ -11,12 +11,21 @@ module Legion
     module MicrosoftTeams
       module Runners
         module ProfileIngest
+          extend Legion::Extensions::Definitions
           include Helpers::Client
           include Helpers::PermissionGuard
           include Helpers::HighWaterMark
           extend self
 
+          definition :full_ingest, mcp_exposed: false
+          definition :ingest_self, mcp_exposed: false
+          definition :ingest_people, mcp_exposed: false
+          definition :ingest_conversations, mcp_exposed: false
+          definition :ingest_teams_and_meetings, mcp_exposed: false
+          definition :incremental_sync, mcp_exposed: false
+
           def full_ingest(token:, top_people: 10, message_depth: 50, **)
+            log.debug("ProfileIngest#full_ingest top_people=#{top_people} message_depth=#{message_depth}")
             self_result = ingest_self(token: token)
             people_result = ingest_people(token: token, top: 25)
             people = people_result[:skipped] ? [] : (people_result[:people] || [])
@@ -42,7 +51,7 @@ module Legion
             presence = begin
               conn.get('me/presence').body
             rescue StandardError => e
-              log.debug("ProfileIngest: presence fetch failed: #{e.message}") if defined?(log)
+              handle_exception(e, level: :debug, operation: 'ProfileIngest#ingest_self presence') if defined?(handle_exception)
               {}
             end
             unless presence.empty?
@@ -57,6 +66,7 @@ module Legion
 
             { profile: profile, presence: presence }
           rescue StandardError => e
+            handle_exception(e, level: :error, operation: 'ProfileIngest#ingest_self')
             { error: e.message }
           end
 
@@ -88,6 +98,7 @@ module Legion
 
             { people: people, count: people.length }
           rescue StandardError => e
+            handle_exception(e, level: :error, operation: 'ProfileIngest#ingest_people')
             { error: e.message, skipped: false }
           end
 
@@ -132,6 +143,7 @@ module Legion
 
             { ingested: ingested }
           rescue StandardError => e
+            handle_exception(e, level: :error, operation: 'ProfileIngest#ingest_conversations')
             { error: e.message, ingested: ingested || 0 }
           end
 
@@ -177,6 +189,7 @@ module Legion
 
             { teams: teams_count, meetings: meetings_count }
           rescue StandardError => e
+            handle_exception(e, level: :error, operation: 'ProfileIngest#ingest_teams_and_meetings')
             { error: e.message }
           end
 
@@ -200,7 +213,7 @@ module Legion
               members.any? { |m| m['email']&.downcase == email.downcase }
             end
           rescue StandardError => e
-            log.debug("ProfileIngest: find_chat_for_person failed: #{e.message}")
+            handle_exception(e, level: :debug, operation: 'ProfileIngest#find_chat_for_person')
             nil
           end
 
@@ -212,7 +225,8 @@ module Legion
             resp = conn.get("chats/#{chat_id}/messages", params)
             (resp.body || {}).fetch('value', [])
           rescue StandardError => e
-            log.warn("ProfileIngest: fetch_new_messages failed for #{chat_id}: #{e.message}")
+            handle_exception(e, level: :warn, operation: 'ProfileIngest#fetch_new_messages',
+                             chat_id: chat_id)
             []
           end
 
@@ -233,7 +247,7 @@ module Legion
               llm_ask(message: "#{definition[:prompt]}\n\nConversation with #{peer_name}:\n#{text}")
             end
           rescue StandardError => e
-            log.debug("ProfileIngest: extract_conversation failed: #{e.message}")
+            handle_exception(e, level: :debug, operation: 'ProfileIngest#extract_conversation')
             nil
           end
 

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

@@ -9,16 +9,55 @@ module Legion
         module Subscriptions
           include Legion::Extensions::MicrosoftTeams::Helpers::Client
 
+          def self.trigger_words
+            %w[subscription subscriptions webhook webhooks subscribe watch]
+          end
+
+          definition :list_subscriptions,
+                     desc:          'List active Graph API subscriptions',
+                     mcp_prefix:    'teams.list_subscriptions',
+                     mcp_category:  'teams_subscriptions',
+                     mcp_tier:      :standard,
+                     idempotent:    true,
+                     trigger_words: %w[subscriptions webhooks]
+
           def list_subscriptions(**)
             response = graph_connection(**).get('subscriptions')
             { result: response.body }
           end
 
+          definition :get_subscription,
+                     desc:          'Get a specific Graph API subscription',
+                     mcp_prefix:    'teams.get_subscription',
+                     mcp_category:  'teams_subscriptions',
+                     mcp_tier:      :standard,
+                     idempotent:    true,
+                     inputs:        { properties: { subscription_id: { type: 'string' } },
+                                      required:   ['subscription_id'] },
+                     trigger_words: %w[subscription webhook]
+
           def get_subscription(subscription_id:, **)
             response = graph_connection(**).get("subscriptions/#{subscription_id}")
             { result: response.body }
           end
 
+          definition :create_subscription,
+                     desc:          'Create a new Graph API change notification subscription',
+                     mcp_prefix:    'teams.create_subscription',
+                     mcp_category:  'teams_subscriptions',
+                     mcp_tier:      :elevated,
+                     idempotent:    false,
+                     inputs:        { properties: { resource:         { type:        'string',
+                                                                        description: 'Graph resource path to subscribe to' },
+                                                    change_type:      { type:        'string',
+                                                                        description: 'created, updated, deleted' },
+                                                    notification_url: { type:        'string',
+                                                                        description: 'HTTPS webhook URL' },
+                                                    expiration:       { type:        'string',
+                                                                        description: 'ISO 8601 expiration datetime' } },
+                                      required:   %w[resource change_type notification_url expiration] },
+                     trigger_words: %w[subscribe webhook create]
+
           def create_subscription(resource:, change_type:, notification_url:, expiration:,
                                   client_state: nil, include_resource_data: false, **)
             payload = {
@@ -33,17 +72,51 @@ module Legion
             { result: response.body }
           end
 
+          definition :renew_subscription,
+                     desc:          'Renew an expiring Graph API subscription',
+                     mcp_prefix:    'teams.renew_subscription',
+                     mcp_category:  'teams_subscriptions',
+                     mcp_tier:      :elevated,
+                     idempotent:    false,
+                     inputs:        { properties: { subscription_id: { type: 'string' },
+                                                    expiration:      { type:        'string',
+                                                                       description: 'New ISO 8601 expiration datetime' } },
+                                      required:   %w[subscription_id expiration] },
+                     trigger_words: %w[renew extend]
+
           def renew_subscription(subscription_id:, expiration:, **)
             payload = { expirationDateTime: expiration }
             response = graph_connection(**).patch("subscriptions/#{subscription_id}", payload)
             { result: response.body }
           end
 
+          definition :delete_subscription,
+                     desc:          'Delete a Graph API subscription',
+                     mcp_prefix:    'teams.delete_subscription',
+                     mcp_category:  'teams_subscriptions',
+                     mcp_tier:      :elevated,
+                     idempotent:    false,
+                     inputs:        { properties: { subscription_id: { type: 'string' } },
+                                      required:   ['subscription_id'] },
+                     trigger_words: %w[unsubscribe delete]
+
           def delete_subscription(subscription_id:, **)
             response = graph_connection(**).delete("subscriptions/#{subscription_id}")
             { result: response.body }
           end
 
+          definition :subscribe_to_chat_messages,
+                     desc:          'Subscribe to new and updated messages in a Teams chat',
+                     mcp_prefix:    'teams.subscribe_to_chat_messages',
+                     mcp_category:  'teams_subscriptions',
+                     mcp_tier:      :elevated,
+                     idempotent:    false,
+                     inputs:        { properties: { chat_id:          { type: 'string' },
+                                                    notification_url: { type: 'string' },
+                                                    expiration:       { type: 'string' } },
+                                      required:   %w[chat_id notification_url expiration] },
+                     trigger_words: %w[subscribe watch chat]
+
           def subscribe_to_chat_messages(chat_id:, notification_url:, expiration:, client_state: nil, **)
             create_subscription(
               resource:         "/chats/#{chat_id}/messages",
@@ -55,6 +128,19 @@ module Legion
             )
           end
 
+          definition :subscribe_to_channel_messages,
+                     desc:          'Subscribe to new and updated messages in a Teams channel',
+                     mcp_prefix:    'teams.subscribe_to_channel_messages',
+                     mcp_category:  'teams_subscriptions',
+                     mcp_tier:      :elevated,
+                     idempotent:    false,
+                     inputs:        { properties: { team_id:          { type: 'string' },
+                                                    channel_id:       { type: 'string' },
+                                                    notification_url: { type: 'string' },
+                                                    expiration:       { type: 'string' } },
+                                      required:   %w[team_id channel_id notification_url expiration] },
+                     trigger_words: %w[subscribe watch channel]
+
           def subscribe_to_channel_messages(team_id:, channel_id:, notification_url:, expiration:,
                                             client_state: nil, **)
             create_subscription(

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

@@ -9,16 +9,46 @@ module Legion
         module Teams
           include Legion::Extensions::MicrosoftTeams::Helpers::Client
 
+          def self.trigger_words
+            %w[team teams workspace group membership]
+          end
+
+          definition :list_joined_teams,
+                     desc:          'List Teams the current user has joined',
+                     mcp_prefix:    'teams.list_joined_teams',
+                     mcp_category:  'teams_teams',
+                     mcp_tier:      :low,
+                     idempotent:    true,
+                     trigger_words: %w[teams joined membership]
+
           def list_joined_teams(user_id: 'me', **)
             response = graph_connection(**).get("#{user_path(user_id)}/joinedTeams")
             { result: response.body }
           end
 
+          definition :get_team,
+                     desc:          'Get details for a specific Team by ID',
+                     mcp_prefix:    'teams.get_team',
+                     mcp_category:  'teams_teams',
+                     mcp_tier:      :low,
+                     idempotent:    true,
+                     inputs:        { properties: { team_id: { type: 'string' } }, required: ['team_id'] },
+                     trigger_words: %w[team details workspace]
+
           def get_team(team_id:, **)
             response = graph_connection(**).get("teams/#{team_id}")
             { result: response.body }
           end
 
+          definition :list_team_members,
+                     desc:          'List members of a Team',
+                     mcp_prefix:    'teams.list_team_members',
+                     mcp_category:  'teams_teams',
+                     mcp_tier:      :standard,
+                     idempotent:    true,
+                     inputs:        { properties: { team_id: { type: 'string' } }, required: ['team_id'] },
+                     trigger_words: %w[members roster]
+
           def list_team_members(team_id:, **)
             response = graph_connection(**).get("teams/#{team_id}/members")
             { result: response.body }

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

@@ -14,11 +14,35 @@ module Legion
             docx: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document'
           }.freeze
 
+          def self.trigger_words
+            %w[transcript transcripts vtt spoken]
+          end
+
+          definition :list_transcripts,
+                     desc:          'List transcripts for an online meeting',
+                     mcp_prefix:    'teams.list_transcripts',
+                     mcp_category:  'teams_meetings',
+                     mcp_tier:      :standard,
+                     idempotent:    true,
+                     inputs:        { properties: { meeting_id: { type: 'string' } }, required: ['meeting_id'] },
+                     trigger_words: ['transcripts']
+
           def list_transcripts(meeting_id:, user_id: 'me', **)
             response = graph_connection(**).get("#{user_path(user_id)}/onlineMeetings/#{meeting_id}/transcripts")
             { result: response.body }
           end
 
+          definition :get_transcript,
+                     desc:          'Get metadata for a specific meeting transcript',
+                     mcp_prefix:    'teams.get_transcript',
+                     mcp_category:  'teams_meetings',
+                     mcp_tier:      :standard,
+                     idempotent:    true,
+                     inputs:        { properties: { meeting_id:    { type: 'string' },
+                                                    transcript_id: { type: 'string' } },
+                                      required:   %w[meeting_id transcript_id] },
+                     trigger_words: %w[transcript details]
+
           def get_transcript(meeting_id:, transcript_id:, user_id: 'me', **)
             response = graph_connection(**).get(
               "#{user_path(user_id)}/onlineMeetings/#{meeting_id}/transcripts/#{transcript_id}"
@@ -26,6 +50,17 @@ module Legion
             { result: response.body }
           end
 
+          definition :get_transcript_content,
+                     desc:          'Download the content of a meeting transcript (VTT or DOCX)',
+                     mcp_prefix:    'teams.get_transcript_content',
+                     mcp_category:  'teams_meetings',
+                     mcp_tier:      :standard,
+                     idempotent:    true,
+                     inputs:        { properties: { meeting_id:    { type: 'string' },
+                                                    transcript_id: { type: 'string' } },
+                                      required:   %w[meeting_id transcript_id] },
+                     trigger_words: %w[content vtt text read]
+
           def get_transcript_content(meeting_id:, transcript_id:, user_id: 'me', format: :vtt, **)
             accept = CONTENT_TYPES.fetch(format)
             response = graph_connection(**).get(

data/lib/legion/extensions/microsoft_teams/version.rb

@@ -3,7 +3,7 @@
 module Legion
   module Extensions
     module MicrosoftTeams
-      VERSION = '0.6.45'
+      VERSION = '0.6.47'
     end
   end
 end

data/lib/legion/extensions/microsoft_teams.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'legion/extensions/identity/entra/helpers/token_manager'
 require 'legion/extensions/microsoft_teams/version'
 require 'legion/extensions/microsoft_teams/helpers/client'
 require 'legion/extensions/microsoft_teams/runners/auth'
@@ -21,6 +22,11 @@ require 'legion/extensions/microsoft_teams/runners/people'
 require 'legion/extensions/microsoft_teams/runners/profile_ingest'
 require 'legion/extensions/microsoft_teams/runners/ownership'
 require 'legion/extensions/microsoft_teams/runners/api_ingest'
+require 'legion/extensions/microsoft_teams/runners/activities'
+require 'legion/extensions/microsoft_teams/runners/meeting_artifacts'
+require 'legion/extensions/microsoft_teams/runners/call_events'
+require 'legion/extensions/microsoft_teams/runners/app_installations'
+require 'legion/extensions/microsoft_teams/runners/files'
 
 # Helpers (bot)
 require 'legion/extensions/microsoft_teams/helpers/high_water_mark'
@@ -28,9 +34,6 @@ require 'legion/extensions/microsoft_teams/helpers/prompt_resolver'
 require 'legion/extensions/microsoft_teams/helpers/trace_retriever'
 require 'legion/extensions/microsoft_teams/helpers/session_manager'
 require 'legion/extensions/microsoft_teams/helpers/subscription_registry'
-require 'legion/extensions/microsoft_teams/helpers/token_cache'
-require 'legion/extensions/microsoft_teams/helpers/callback_server'
-require 'legion/extensions/microsoft_teams/helpers/browser_auth'
 require 'legion/extensions/microsoft_teams/helpers/permission_guard'
 require 'legion/extensions/microsoft_teams/helpers/transform_definitions'
 require 'legion/extensions/microsoft_teams/helpers/graph_client'
@@ -57,6 +60,10 @@ module Legion
     module MicrosoftTeams
       extend Legion::Extensions::Core if Legion::Extensions.const_defined? :Core, false
 
+      def self.trigger_words
+        %w[teams microsoft_teams microsoftteams microsoft-teams msteams ms-teams]
+      end
+
       def self.remote_invocable?
         false
       end