lex-microsoft_teams 0.6.45 → 0.6.47

data/lib/legion/extensions/microsoft_teams/actors/meeting_ingest.rb

@@ -9,8 +9,8 @@ module Legion
 
           DEFAULT_INGEST_INTERVAL = 300
 
-          def runner_class    = Legion::Extensions::MicrosoftTeams::Helpers::TokenCache
-          def runner_function = 'cached_delegated_token'
+          def runner_class    = self.class
+          def runner_function = 'manual'
           def run_now?        = false
           def use_runner?     = false
           def check_subtask?  = false
@@ -25,16 +25,16 @@ module Legion
             settings = begin
               Legion::Settings[:microsoft_teams] || {}
             rescue StandardError => e
-              log.debug("MeetingIngest#time: #{e.message}")
+              handle_exception(e, level: :debug, operation: 'MeetingIngest#time')
               {}
             end
             settings.dig(:meetings, :ingest_interval) || DEFAULT_INGEST_INTERVAL
           end
 
           def enabled?
-            defined?(Legion::Extensions::MicrosoftTeams::Helpers::TokenCache)
+            Legion::Extensions::Identity::Entra::Helpers::TokenManager.respond_to?(:load_token)
           rescue StandardError => e
-            log.debug("MeetingIngest#enabled?: #{e.message}")
+            handle_exception(e, level: :debug, operation: 'MeetingIngest#enabled?')
             false
           end
 
@@ -46,19 +46,15 @@ module Legion
             @memory_runner ||= Object.new.extend(Legion::Extensions::Agentic::Memory::Trace::Runners::Traces)
           end
 
-          def token_cache
-            Legion::Extensions::MicrosoftTeams::Helpers::TokenCache.instance
-          end
-
           def manual
             log.info('MeetingIngest polling for meetings')
-            token = token_cache.cached_delegated_token
+            token = Legion::Extensions::Identity::Entra::Helpers::TokenManager.load_token(:delegated)
             return if token.nil?
 
             conn = graph_connection(token: token)
             response = conn.get("#{user_path('me')}/onlineMeetings")
             meetings = response.body&.dig('value') || []
-            log.info("Found #{meetings.length} online meeting(s)")
+            log.info("MeetingIngest found #{meetings.length} online meeting(s)")
 
             meetings.each do |meeting|
               meeting_id = meeting['id']
@@ -68,20 +64,22 @@ module Legion
                 process_meeting(meeting_id: meeting_id, subject: meeting['subject'], token: token)
                 @processed_meetings.add(meeting_id)
               rescue StandardError => e
-                log.error("Failed to process meeting #{meeting_id}: #{e.message}")
+                handle_exception(e, level: :error, operation: 'MeetingIngest#manual',
+                                 meeting_id: meeting_id)
               end
             end
           rescue StandardError => e
-            log.error("MeetingIngest: #{e.message}")
+            handle_exception(e, level: :error, operation: 'MeetingIngest#manual')
           end
 
           private
 
           def process_meeting(meeting_id:, subject:, token:)
+            log.debug("MeetingIngest#process_meeting meeting_id=#{meeting_id} subject=#{subject}")
             conn = graph_connection(token: token)
 
             transcripts = fetch_transcripts(conn: conn, meeting_id: meeting_id)
-            log.info("Meeting '#{subject}' (#{meeting_id}): #{transcripts.length} transcript(s)")
+            log.info("MeetingIngest '#{subject}' (#{meeting_id}): #{transcripts.length} transcript(s)")
 
             transcripts.each do |transcript|
               fetch_and_log_transcript_content(
@@ -97,15 +95,18 @@ module Legion
           end
 
           def fetch_transcripts(conn:, meeting_id:)
+            log.debug("MeetingIngest#fetch_transcripts meeting_id=#{meeting_id}")
             response = conn.get("#{user_path('me')}/onlineMeetings/#{meeting_id}/transcripts")
             response.body&.dig('value') || []
           rescue StandardError => e
-            log.warn("Could not fetch transcripts for meeting #{meeting_id}: #{e.message}")
+            handle_exception(e, level: :warn, operation: 'MeetingIngest#fetch_transcripts',
+                             meeting_id: meeting_id)
             []
           end
 
           def fetch_and_log_transcript_content(conn:, meeting_id:, subject:, token:, transcript:) # rubocop:disable Lint/UnusedMethodArgument
             tid = transcript['id']
+            log.debug("MeetingIngest#fetch_and_log_transcript_content meeting_id=#{meeting_id} transcript_id=#{tid}")
             content_conn = graph_connection(token: token)
             content_response = content_conn.get(
               "#{user_path('me')}/onlineMeetings/#{meeting_id}/transcripts/#{tid}/content",
@@ -114,22 +115,24 @@ module Legion
             )
             content = content_response.body.to_s
             preview = content[0, 200]
-            log.debug("Meeting '#{subject}' transcript #{tid}: #{preview}")
+            log.debug("MeetingIngest '#{subject}' transcript #{tid}: #{preview}")
             store_transcript_trace(meeting_id: meeting_id, subject: subject, transcript_id: tid, content: content) if memory_available?
           rescue StandardError => e
-            log.warn("Could not fetch transcript content #{tid} for meeting #{meeting_id}: #{e.message}")
+            handle_exception(e, level: :warn, operation: 'MeetingIngest#fetch_and_log_transcript_content',
+                             meeting_id: meeting_id, transcript_id: tid)
           end
 
           def fetch_and_log_ai_insights(conn:, meeting_id:, subject:)
+            log.debug("MeetingIngest#fetch_and_log_ai_insights meeting_id=#{meeting_id}")
             response = conn.get("#{user_path('me')}/onlineMeetings/#{meeting_id}/aiInsights")
             insights = response.body&.dig('value') || []
-            log.info("Meeting '#{subject}' (#{meeting_id}): #{insights.length} AI insight(s)")
+            log.info("MeetingIngest '#{subject}' (#{meeting_id}): #{insights.length} AI insight(s)")
 
             insights.each do |insight|
               action_items = insight['actionItems'] || []
               next if action_items.empty?
 
-              log.info("Meeting '#{subject}' AI insight action items (#{action_items.length}):")
+              log.info("MeetingIngest '#{subject}' AI insight action items (#{action_items.length}):")
               action_items.each do |item|
                 log.info("  - #{item['text'] || item.inspect}")
               end
@@ -137,10 +140,12 @@ module Legion
               store_insight_trace(meeting_id: meeting_id, subject: subject, insight: insight) if memory_available?
             end
           rescue StandardError => e
-            log.warn("Could not fetch AI insights for meeting #{meeting_id}: #{e.message}")
+            handle_exception(e, level: :warn, operation: 'MeetingIngest#fetch_and_log_ai_insights',
+                             meeting_id: meeting_id)
           end
 
           def store_transcript_trace(meeting_id:, subject:, transcript_id:, content:) # rubocop:disable Lint/UnusedMethodArgument
+            log.debug("MeetingIngest#store_transcript_trace meeting_id=#{meeting_id} transcript_id=#{transcript_id}")
             memory_runner.store_trace(
               type:            :episodic,
               content_payload: content[0, 10_000],
@@ -149,10 +154,12 @@ module Legion
               confidence:      0.9
             )
           rescue StandardError => e
-            log.warn("Could not store transcript trace for meeting #{meeting_id}: #{e.message}")
+            handle_exception(e, level: :warn, operation: 'MeetingIngest#store_transcript_trace',
+                             meeting_id: meeting_id, transcript_id: transcript_id)
           end
 
           def store_insight_trace(meeting_id:, subject:, insight:) # rubocop:disable Lint/UnusedMethodArgument
+            log.debug("MeetingIngest#store_insight_trace meeting_id=#{meeting_id}")
             memory_runner.store_trace(
               type:            :semantic,
               content_payload: insight.to_s,
@@ -161,7 +168,8 @@ module Legion
               confidence:      0.8
             )
           rescue StandardError => e
-            log.warn("Could not store insight trace for meeting #{meeting_id}: #{e.message}")
+            handle_exception(e, level: :warn, operation: 'MeetingIngest#store_insight_trace',
+                             meeting_id: meeting_id)
           end
         end
       end

data/lib/legion/extensions/microsoft_teams/actors/observed_chat_poller.rb

@@ -32,23 +32,21 @@ module Legion
 
             Legion::Settings.dig(:microsoft_teams, :bot, :observe, :enabled) == true
           rescue StandardError => e
-            log.debug("ObservedChatPoller#enabled?: #{e.message}")
+            handle_exception(e, level: :debug, operation: 'ObservedChatPoller#enabled?')
             false
           end
 
-          def token_cache
-            Legion::Extensions::MicrosoftTeams::Helpers::TokenCache.instance
-          end
-
           def subscription_registry
             @subscription_registry ||= Legion::Extensions::MicrosoftTeams::Helpers::SubscriptionRegistry.new
           end
 
           def manual
-            token = token_cache.cached_app_token
+            log.debug('ObservedChatPoller#manual starting')
+            token = delegated_token
             return unless token
 
             subscriptions = subscription_registry.active_subscriptions
+            log.debug("ObservedChatPoller#manual subscriptions=#{subscriptions.length}")
             subscriptions.each do |sub|
               poll_observed_chat(
                 chat_id: sub[:chat_id], owner_id: sub[:owner_id],
@@ -56,12 +54,13 @@ module Legion
               )
             end
           rescue StandardError => e
-            log.error("ObservedChatPoller: #{e.message}")
+            handle_exception(e, level: :error, operation: 'ObservedChatPoller#manual')
           end
 
           private
 
           def poll_observed_chat(chat_id:, owner_id:, peer_name:, token:)
+            log.debug("ObservedChatPoller#poll_observed_chat chat_id=#{chat_id} peer_name=#{peer_name}")
             conn = graph_connection(token: token)
             response = conn.get("chats/#{chat_id}/messages",
                                 { '$top' => 10, '$orderby' => 'createdDateTime desc' })
@@ -85,7 +84,7 @@ module Legion
           def publish_message(payload)
             Legion::Extensions::MicrosoftTeams::Transport::Messages::TeamsMessage.new.publish(payload)
           rescue StandardError => e
-            log.error("ObservedChatPoller publish failed: #{e.message}")
+            handle_exception(e, level: :error, operation: 'ObservedChatPoller#publish_message')
           end
 
           def normalize_messages(messages)
@@ -101,6 +100,13 @@ module Legion
             end
           end
 
+          def delegated_token
+            Legion::Extensions::Identity::Entra::Helpers::TokenManager.load_token(:delegated)
+          rescue StandardError => e
+            handle_exception(e, level: :warn, operation: 'ObservedChatPoller#delegated_token')
+            nil
+          end
+
           def settings_interval(key, default)
             return default unless defined?(Legion::Settings)
 

data/lib/legion/extensions/microsoft_teams/actors/presence_poller.rb

@@ -23,18 +23,15 @@ module Legion
           end
 
           def enabled?
-            defined?(Legion::Extensions::MicrosoftTeams::Helpers::TokenCache)
+            Legion::Extensions::Identity::Entra::Helpers::TokenManager.respond_to?(:load_token)
           rescue StandardError => e
-            log.debug("PresencePoller#enabled?: #{e.message}")
+            handle_exception(e, level: :debug, operation: 'PresencePoller#enabled?')
             false
           end
 
-          def token_cache
-            Legion::Extensions::MicrosoftTeams::Helpers::TokenCache.instance
-          end
-
           def manual
-            token = token_cache.cached_delegated_token
+            log.debug('PresencePoller#manual starting')
+            token = delegated_token
             unless token
               log.debug('No token available, skipping presence poll')
               return
@@ -56,7 +53,16 @@ module Legion
               @last_presence = current
             end
           rescue StandardError => e
-            log.error("PresencePoller: #{e.message}")
+            handle_exception(e, level: :error, operation: 'PresencePoller#manual')
+          end
+
+          private
+
+          def delegated_token
+            Legion::Extensions::Identity::Entra::Helpers::TokenManager.load_token(:delegated)
+          rescue StandardError => e
+            handle_exception(e, level: :warn, operation: 'PresencePoller#delegated_token')
+            nil
           end
         end
       end

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

@@ -12,20 +12,19 @@ module Legion
           def generate_task?  = false
 
           def delay
-            if defined?(Legion::Extensions::MicrosoftTeams::Actor::AuthValidator)
-              auth_validator = Legion::Extensions::MicrosoftTeams::Actor::AuthValidator.allocate
-              base_delay = auth_validator.respond_to?(:delay) ? auth_validator.delay.to_f : 90.0
-              base_delay + 5.0
-            else
-              95.0
-            end
+            auth_validator = Legion::Extensions::Identity::Entra::Delegated::Actor::AuthValidator.allocate
+            base_delay = auth_validator.respond_to?(:delay) ? auth_validator.delay.to_f : 9.0
+            base_delay + 5.0
+          rescue StandardError => e
+            handle_exception(e, level: :debug, operation: 'ProfileIngest#delay')
+            14.0
           end
 
           def enabled?
             defined?(Legion::Extensions::Agentic::Memory::Trace::Runners::Traces) &&
               token_available?
           rescue StandardError => e
-            log.debug("ProfileIngest#enabled?: #{e.message}")
+            handle_exception(e, level: :debug, operation: 'ProfileIngest#enabled?')
             false
           end
 
@@ -33,15 +32,15 @@ module Legion
             log.info('ProfileIngest firing')
             token = resolve_token
             unless token
-              log.warn('No token available, skipping')
+              log.warn('ProfileIngest: no token available, skipping')
               return
             end
-            log.info('Token acquired, starting ingest')
+            log.info('ProfileIngest: token acquired, starting ingest')
 
             settings = begin
               Legion::Settings[:microsoft_teams] || {}
             rescue StandardError => e
-              log.debug("ProfileIngest#manual settings: #{e.message}")
+              handle_exception(e, level: :debug, operation: 'ProfileIngest#manual settings')
               {}
             end
             ingest = settings[:ingest] || {}
@@ -51,7 +50,7 @@ module Legion
               message_depth: ingest.fetch(:message_depth, 50)
             )
           rescue StandardError => e
-            log.error("ProfileIngest: #{e.message}")
+            handle_exception(e, level: :error, operation: 'ProfileIngest#manual')
           end
 
           private
@@ -61,11 +60,9 @@ module Legion
           end
 
           def resolve_token
-            if defined?(Legion::Extensions::MicrosoftTeams::Helpers::TokenCache)
-              Legion::Extensions::MicrosoftTeams::Helpers::TokenCache.instance.cached_delegated_token
-            end
+            Legion::Extensions::Identity::Entra::Helpers::TokenManager.load_token(:delegated)
           rescue StandardError => e
-            log.warn("ProfileIngest#resolve_token: #{e.message}")
+            handle_exception(e, level: :warn, operation: 'ProfileIngest#resolve_token')
             nil
           end
         end

data/lib/legion/extensions/microsoft_teams/helpers/client.rb

@@ -11,8 +11,7 @@ module Legion
                                                       Legion::Extensions::Helpers.const_defined?(:Lex, false)
 
           def graph_connection(token: nil, api_url: 'https://graph.microsoft.com/v1.0', **_opts)
-            token ||= settings&.dig(:auth, :delegated, :token)
-            token ||= TokenCache.instance.cached_delegated_token if defined?(TokenCache)
+            token ||= entra_delegated_token
             Faraday.new(url: api_url) do |conn|
               conn.request :json
               conn.response :json, content_type: /\bjson$/
@@ -22,8 +21,6 @@ module Legion
           end
 
           def bot_connection(token: nil, service_url: 'https://smba.trafficmanager.net/teams/', **_opts)
-            token ||= settings&.dig(:auth, :bot, :token)
-            token ||= TokenCache.instance.cached_app_token if defined?(TokenCache)
             Faraday.new(url: service_url) do |conn|
               conn.request :json
               conn.response :json, content_type: /\bjson$/
@@ -42,6 +39,15 @@ module Legion
               conn.response :json, content_type: /\bjson$/
             end
           end
+
+          private
+
+          def entra_delegated_token
+            Legion::Extensions::Identity::Entra::Helpers::TokenManager.load_token(:delegated)
+          rescue StandardError => e
+            handle_exception(e, level: :debug, operation: 'Client#entra_delegated_token')
+            nil
+          end
         end
       end
     end

data/lib/legion/extensions/microsoft_teams/helpers/high_water_mark.rb

@@ -59,7 +59,8 @@ module Legion
 
             raw.is_a?(Hash) ? raw : ::JSON.parse(raw, symbolize_names: true)
           rescue StandardError => e
-            log.debug("HighWaterMark: get_extended_hwm failed to parse cached value: #{e.message}")
+            handle_exception(e, level: :debug, operation: 'HighWaterMark#get_extended_hwm',
+                             chat_id: chat_id)
             nil
           end
 
@@ -108,7 +109,7 @@ module Legion
                                last_ingested_at: data[:last_ingested_at], message_count: data[:message_count] || 0)
             end
           rescue StandardError => e
-            log.warn("Failed to restore HWM from traces: #{e.message}")
+            handle_exception(e, level: :warn, operation: 'HighWaterMark#restore_hwm_from_traces')
           end
 
           def memory_runner

data/lib/legion/extensions/microsoft_teams/helpers/prompt_resolver.rb

@@ -54,7 +54,10 @@ module Legion
             profile = Legion::Extensions::Mesh::Helpers::PreferenceProfile.resolve(owner_id: owner_id)
             Legion::Extensions::Mesh::Helpers::PreferenceProfile.preference_instructions(profile: profile)
           rescue StandardError => e
-            log.debug("PromptResolver: preference_instructions_for failed: #{e.message}") if defined?(log)
+            if defined?(handle_exception)
+              handle_exception(e, level: :debug, operation: 'PromptResolver#preference_instructions_for',
+                               owner_id: owner_id)
+            end
             nil
           end
         end

data/lib/legion/extensions/microsoft_teams/helpers/session_manager.rb

@@ -115,6 +115,7 @@ module Legion
           def store_session_to_memory(conversation_id:, session:)
             return unless defined?(Legion::Extensions::Agentic::Memory::Trace::Runners::Traces)
 
+            log.debug("SessionManager#store_session_to_memory conversation_id=#{conversation_id}")
             memory_runner.store_trace(
               type:            :episodic,
               content_payload: {
@@ -129,8 +130,10 @@ module Legion
               origin:          :direct_experience,
               confidence:      0.8
             )
+            log.info("SessionManager: stored session trace conversation_id=#{conversation_id}")
           rescue StandardError => e
-            log.error("SessionManager persist failed: #{e.message}")
+            handle_exception(e, level: :error, operation: 'SessionManager#store_session_to_memory',
+                             conversation_id: conversation_id)
           end
 
           def memory_runner
@@ -149,7 +152,10 @@ module Legion
 
             profile_traces.map { |t| { type: t[:trace_type], content: t[:content_payload].to_s[0, 200] } }
           rescue StandardError => e
-            log.debug("trace_seed_for failed: #{e.message}") if defined?(log) && log.respond_to?(:debug)
+            if defined?(handle_exception)
+              handle_exception(e, level: :debug, operation: 'SessionManager#trace_seed_for',
+                               owner_id: owner_id)
+            end
             nil
           end
 

data/lib/legion/extensions/microsoft_teams/helpers/subscription_registry.rb

@@ -88,12 +88,13 @@ module Legion
             parsed = parse_stored(stored[:content_payload])
             @mutex.synchronize { @subscriptions = parsed } if parsed.is_a?(Hash)
           rescue StandardError => e
-            log.error("SubscriptionRegistry load failed: #{e.message}")
+            handle_exception(e, level: :error, operation: 'SubscriptionRegistry#load')
           end
 
           def persist
             return unless memory_available?
 
+            log.debug('SubscriptionRegistry#persist')
             memory_runner.store_trace(
               type:            :semantic,
               content_payload: serialize_subscriptions,
@@ -101,8 +102,9 @@ module Legion
               origin:          :system,
               confidence:      1.0
             )
+            log.info("SubscriptionRegistry: persisted #{@subscriptions.size} subscription(s)")
           rescue StandardError => e
-            log.error("SubscriptionRegistry persist failed: #{e.message}")
+            handle_exception(e, level: :error, operation: 'SubscriptionRegistry#persist')
           end
 
           private
@@ -124,7 +126,7 @@ module Legion
               v
             end
           rescue ::JSON::ParserError => e
-            log.warn("SubscriptionRegistry: corrupted subscription data, resetting: #{e.message}")
+            handle_exception(e, level: :warn, operation: 'SubscriptionRegistry#parse_stored')
             {}
           end
 

data/lib/legion/extensions/microsoft_teams/helpers/trace_retriever.rb

@@ -9,6 +9,7 @@ module Legion
           MAX_TRACES = 20
 
           def retrieve_context(message:, owner_id:, chat_id: nil, channel_id: nil) # rubocop:disable Lint/UnusedMethodArgument
+            log.debug("TraceRetriever#retrieve_context owner_id=#{owner_id} chat_id=#{chat_id}") if defined?(log)
             return nil unless memory_trace_available?
 
             traces = []
@@ -129,7 +130,11 @@ module Legion
           def log_trace_error(method, error)
             return unless defined?(log)
 
-            log.debug("TraceRetriever##{method} failed: #{error.message}")
+            if defined?(handle_exception)
+              handle_exception(error, level: :debug, operation: "TraceRetriever##{method}")
+            else
+              log.debug("TraceRetriever##{method} failed: #{error.message}")
+            end
           end
         end
       end

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

@@ -71,7 +71,7 @@ module Legion
                 extract_from_record(value, messages, seen_hashes)
               end
             rescue StandardError => e
-              warn "LocalCache: error reading #{File.basename(path)}: #{e.message}"
+              warn "LocalCache: error reading #{File.basename(path)}: #{e.class} — #{e.message}"
             end
 
             messages = apply_filters(messages, since: since, channels: channels,

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

@@ -58,7 +58,8 @@ module Legion
             when 0x00 then block
             when 0x01 then Snappy.inflate(block)
             end
-          rescue Snappy::Error => _e
+          rescue Snappy::Error => e
+            warn "SSTableReader: snappy decompression failed at offset=#{offset}: #{e.message}"
             nil
           end
 

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/microsoft_teams/helpers/client'
+
+module Legion
+  module Extensions
+    module MicrosoftTeams
+      module Runners
+        module Activities
+          extend Legion::Extensions::Definitions
+          include Legion::Extensions::MicrosoftTeams::Helpers::Client
+
+          def self.trigger_words
+            %w[notification notifications activity alert alerts]
+          end
+
+          definition :send_activity_notification,
+                     desc:          'Send an activity notification to a Teams user',
+                     mcp_prefix:    'teams.send_activity_notification',
+                     mcp_category:  'teams_activities',
+                     mcp_tier:      :elevated,
+                     idempotent:    false,
+                     inputs:        { properties: { topic:         { type:        'string',
+                                                                     description: 'Notification topic object' },
+                                                    activity_type: { type:        'string',
+                                                                     description: 'Activity type registered in app manifest' } },
+                                      required:   %w[topic activity_type] },
+                     trigger_words: %w[notify notification activity]
+
+          def send_activity_notification(topic:, activity_type:, user_id: 'me', preview_text: nil, **)
+            payload = { topic: topic, activityType: activity_type }
+            payload[:previewText] = preview_text if preview_text
+            response = graph_connection(**).post("#{user_path(user_id)}/teamwork/sendActivityNotification", 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
+      end
+    end
+  end
+end