lex-microsoft_teams 0.6.4 → 0.6.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6fccc37def8926f79ed1626030932012a3ac6875ee711b577c7ccd027a1158b4
-  data.tar.gz: 251f6d348cc76c15d226090375f121bac73c5e1b0de95bd70ea9bc975a4e93a9
+  metadata.gz: fd2d2ac7556a1fcc52771005868ce843b3a8fef46dc9976be60a7eb012213bdc
+  data.tar.gz: 07d0d60609364d9a622bc26976b7c34e2a18fa5fba8c0b519873613d106cfb9d
 SHA512:
-  metadata.gz: 3b326a71937fd36b9c98385b41d21f9600ce9ab9b28e7f91261e85b3bb117af6a84365c47d86152f67b34260f8068c1d1d8891abe82925e204f89380f2080e4e
-  data.tar.gz: 4ba5d4507933666d677e8d53bf1100556d88ad7abc7617b6b20b854419a2951f4de569abcb3faea4052d0c3bbe0d8eba6b4c96f85ad36125d1bc412ed8573f89
+  metadata.gz: 94583b4e0b8fa58b1d5fbb49a851859a42cb22078debb5379cc68f44e5e0fa61da55aca0ab469791a4ee72c0bf763526fe69e7473186a6dbf3deb9395b4d5298
+  data.tar.gz: 7f6971571bc4fde09bf690a922b5aa262fdb2b314e2cffd261530b77643f124be67336d2d6008c1bf14d3ae493d936fa79ab38ece856f62774489ee4427d841d

data/CHANGELOG.md

@@ -1,5 +1,40 @@
 # Changelog
 
+## [0.6.6] - 2026-03-22
+
+### Added
+- `Bot.dispatch_message` routes AMQP messages by mode (direct -> handle_message, observe -> observe_message)
+- MeetingIngest stores transcripts as episodic traces and AI insights as semantic traces in lex-agentic-memory
+- ChannelPoller stores new channel messages as episodic traces in lex-agentic-memory
+- INFO-level poll logging in MeetingIngest and ChannelPoller for visibility
+
+### Changed
+- MessageProcessor actor now calls `dispatch_message` instead of `handle_message` directly
+
+## [0.6.5] - 2026-03-22
+
+### Added
+- `Actors::ChannelPoller` (Every, 60s): polls joined team channels for new messages with HWM dedup
+- `Actors::MeetingIngest` (Every, 5min): polls online meetings, fetches transcripts (VTT) and AI insights
+- `Actors::PresencePoller` (Every, 60s): polls Graph API presence, logs changes at INFO
+- `Runners::AiInsights` for Graph API meeting AI insights, recordings, and call records
+- All 28 Entra delegated permission scopes in `BrowserAuth::DEFAULT_SCOPES`
+- Comprehensive tagged logging throughout auth, token, and poller lifecycles
+- `TokenCache.instance` singleton pattern for shared token state across all actors
+- `force_local_server` option in `BrowserAuth` for CLI OAuth flow
+- `hook_route_registered?` HTTP probe for daemon OAuth callback detection
+- Environment variable fallback (`AZURE_TENANT_ID`, `AZURE_CLIENT_ID`) in CLI and actors
+
+### Fixed
+- Fix memory namespace: `Legion::Extensions::Memory::*` -> `Legion::Extensions::Agentic::Memory::Trace::*` across 6 files
+- Fix `SubscriptionRegistry` using nonexistent `recall_trace` method, now uses `retrieve_by_domain`
+- Fix Vault write attempts when `crypt.vault.enabled` is false (added `vault_available?` guard)
+- Fix token not shared across actors (each created own `TokenCache.new` instead of singleton)
+- Fix app token warning spam with warn-once pattern and delegated token fallback
+
+### Changed
+- Updated `AuthValidator` spec to match rewritten `manual` method logic
+
 ## [0.6.4] - 2026-03-22
 
 ### Added

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

@@ -20,28 +20,34 @@ module Legion
           end
 
           def token_cache
-            @token_cache ||= Legion::Extensions::MicrosoftTeams::Helpers::TokenCache.new
+            Legion::Extensions::MicrosoftTeams::Helpers::TokenCache.instance
           end
 
           def manual
-            loaded = token_cache.load_from_vault
+            log_info('AuthValidator starting')
+            cache = token_cache
+            log_debug("Token loaded: authenticated?=#{cache.authenticated?}")
 
-            if loaded
-              token = token_cache.cached_delegated_token
+            if cache.authenticated?
+              token = cache.cached_delegated_token
               if token
-                log_info('Teams delegated auth restored')
-              elsif token_cache.previously_authenticated? || auto_authenticate?
-                attempt_browser_reauth(token_cache)
+                log_info('Teams delegated auth restored (token valid)')
+              elsif cache.previously_authenticated? || auto_authenticate?
+                log_info('Token loaded but expired, attempting browser re-auth')
+                attempt_browser_reauth(cache)
+              else
+                log_debug('Token loaded but expired, no re-auth configured')
               end
-            elsif token_cache.previously_authenticated?
+            elsif cache.previously_authenticated?
               log_warn('Token file found but could not load, attempting re-authentication')
-              attempt_browser_reauth(token_cache)
+              attempt_browser_reauth(cache)
             elsif auto_authenticate?
               log_info('auto_authenticate enabled, opening browser for initial authentication...')
-              attempt_browser_reauth(token_cache)
+              attempt_browser_reauth(cache)
             else
               log_debug('No Teams delegated auth configured, skipping')
             end
+            log_info('AuthValidator complete')
           rescue StandardError => e
             log_error("AuthValidator: #{e.message}")
           end
@@ -50,12 +56,16 @@ module Legion
 
           def attempt_browser_reauth(cache)
             settings = teams_auth_settings
-            return false unless settings[:tenant_id] && settings[:client_id]
+            unless settings[:tenant_id] && settings[:client_id]
+              log_warn("Cannot re-auth: tenant_id=#{settings[:tenant_id] ? 'present' : 'nil'}, client_id=#{settings[:client_id] ? 'present' : 'nil'}")
+              return false
+            end
 
             log_warn('Delegated token expired, opening browser for re-authentication...')
 
             scopes = settings.dig(:delegated, :scopes) ||
                      Legion::Extensions::MicrosoftTeams::Helpers::BrowserAuth::DEFAULT_SCOPES
+            log_debug("Using scopes: #{scopes}")
             browser_auth = Legion::Extensions::MicrosoftTeams::Helpers::BrowserAuth.new(
               tenant_id: settings[:tenant_id],
               client_id: settings[:client_id],
@@ -63,9 +73,13 @@ module Legion
             )
 
             result = browser_auth.authenticate
-            return false if result[:error]
+            if result[:error]
+              log_error("Browser auth returned error: #{result[:error]} - #{result[:description]}")
+              return false
+            end
 
             body = result[:result]
+            log_info("Browser auth succeeded, storing token (expires_in=#{body['expires_in']})")
             cache.store_delegated_token(
               access_token:  body['access_token'],
               refresh_token: body['refresh_token'],
@@ -82,29 +96,36 @@ module Legion
 
           def auto_authenticate?
             settings = teams_auth_settings
-            settings.dig(:delegated, :auto_authenticate) == true
+            result = settings.dig(:delegated, :auto_authenticate) == true
+            log_debug("auto_authenticate? => #{result}")
+            result
           end
 
           def teams_auth_settings
-            return {} unless defined?(Legion::Settings)
-
-            Legion::Settings.dig(:microsoft_teams, :auth) || {}
+            settings = if defined?(Legion::Settings)
+                         Legion::Settings.dig(:microsoft_teams, :auth) || {}
+                       else
+                         {}
+                       end
+            settings[:tenant_id] ||= ENV.fetch('AZURE_TENANT_ID', nil)
+            settings[:client_id] ||= ENV.fetch('AZURE_CLIENT_ID', nil)
+            settings
           end
 
           def log_info(msg)
-            Legion::Logging.info(msg) if defined?(Legion::Logging)
+            Legion::Logging.info("[Teams::AuthValidator] #{msg}") if defined?(Legion::Logging)
           end
 
           def log_warn(msg)
-            Legion::Logging.warn(msg) if defined?(Legion::Logging)
+            Legion::Logging.warn("[Teams::AuthValidator] #{msg}") if defined?(Legion::Logging)
           end
 
           def log_debug(msg)
-            Legion::Logging.debug(msg) if defined?(Legion::Logging)
+            Legion::Logging.debug("[Teams::AuthValidator] #{msg}") if defined?(Legion::Logging)
           end
 
           def log_error(msg)
-            Legion::Logging.error(msg) if defined?(Legion::Logging)
+            Legion::Logging.error("[Teams::AuthValidator] #{msg}") if defined?(Legion::Logging)
           end
         end
       end

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

@@ -16,7 +16,7 @@ module Legion
           end
 
           def enabled?
-            defined?(Legion::Extensions::Memory::Runners::Traces)
+            defined?(Legion::Extensions::Agentic::Memory::Trace::Runners::Traces)
           rescue StandardError
             false
           end

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

@@ -23,7 +23,7 @@ module Legion
           def generate_task?  = false
 
           def enabled?
-            defined?(Legion::Extensions::Memory::Runners::Traces)
+            defined?(Legion::Extensions::Agentic::Memory::Trace::Runners::Traces)
           rescue StandardError
             false
           end

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

@@ -0,0 +1,193 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module MicrosoftTeams
+      module Actor
+        class ChannelPoller < Legion::Extensions::Actors::Every
+          include Legion::Extensions::MicrosoftTeams::Helpers::Client
+
+          DEFAULT_INTERVAL       = 60
+          DEFAULT_MAX_TEAMS      = 10
+          DEFAULT_MAX_CHANNELS   = 5
+
+          def initialize(**opts)
+            return unless enabled?
+
+            @channel_hwm = {}
+            super
+          end
+
+          def runner_class    = self.class
+          def runner_function = 'manual'
+          def time            = channel_setting(:poll_interval, DEFAULT_INTERVAL)
+          def run_now?        = false
+          def use_runner?     = false
+          def check_subtask?  = false
+          def generate_task?  = false
+
+          def memory_available?
+            defined?(Legion::Extensions::Agentic::Memory::Trace::Runners::Traces)
+          end
+
+          def memory_runner
+            @memory_runner ||= Object.new.extend(Legion::Extensions::Agentic::Memory::Trace::Runners::Traces)
+          end
+
+          def enabled?
+            return false unless defined?(Legion::Extensions::MicrosoftTeams::Helpers::TokenCache)
+
+            channel_setting(:enabled, false) == true
+          rescue StandardError
+            false
+          end
+
+          def token_cache
+            Legion::Extensions::MicrosoftTeams::Helpers::TokenCache.instance
+          end
+
+          def manual
+            log_info('ChannelPoller polling team channels')
+            token = token_cache.cached_graph_token
+            unless token
+              log_debug('No token available, skipping poll')
+              return
+            end
+
+            teams = fetch_joined_teams(token: token)
+            log_debug("Found #{teams.length} joined team(s)")
+
+            teams.first(max_teams).each do |team|
+              poll_team(team: team, token: token)
+            rescue StandardError => e
+              log_error("Error polling team #{team['displayName']}: #{e.message}")
+            end
+          rescue StandardError => e
+            log_error("ChannelPoller: #{e.message}")
+          end
+
+          private
+
+          def fetch_joined_teams(token:)
+            conn = graph_connection(token: token)
+            response = conn.get('me/joinedTeams')
+            response.body&.dig('value') || []
+          rescue StandardError => e
+            log_error("Failed to fetch joined teams: #{e.message}")
+            []
+          end
+
+          def poll_team(team:, token:)
+            team_id   = team['id']
+            team_name = team['displayName'] || team_id
+
+            channels = fetch_channels(team_id: team_id, token: token)
+            selected = select_channels(channels)
+
+            selected.first(max_channels_per_team).each do |channel|
+              poll_channel(team_id: team_id, team_name: team_name, channel: channel, token: token)
+            rescue StandardError => e
+              log_error("Error polling channel #{channel['displayName']} in #{team_name}: #{e.message}")
+            end
+          end
+
+          def fetch_channels(team_id:, token:)
+            conn = graph_connection(token: token)
+            response = conn.get("teams/#{team_id}/channels")
+            response.body&.dig('value') || []
+          rescue StandardError => e
+            log_error("Failed to fetch channels for team #{team_id}: #{e.message}")
+            []
+          end
+
+          def select_channels(channels)
+            return channels if channel_setting(:all_channels, false) == true
+
+            general = channels.select { |c| c['displayName'] == 'General' }
+            general.any? ? general : channels
+          end
+
+          def poll_channel(team_id:, team_name:, channel:, token:)
+            channel_id   = channel['id']
+            channel_name = channel['displayName'] || channel_id
+
+            conn     = graph_connection(token: token)
+            response = conn.get(
+              "teams/#{team_id}/channels/#{channel_id}/messages",
+              { '$top' => 10, '$orderby' => 'lastModifiedDateTime desc' }
+            )
+            messages = response.body&.dig('value') || []
+
+            new_msgs = filter_new_messages(channel_id: channel_id, messages: messages)
+            return if new_msgs.empty?
+
+            log_info("#{team_name} / #{channel_name}: #{new_msgs.length} new message(s)")
+            new_msgs.each do |msg|
+              log_message(team_name: team_name, channel_name: channel_name, msg: msg)
+              store_channel_message_trace(team_name: team_name, channel_name: channel_name, msg: msg) if memory_available?
+            end
+
+            latest = new_msgs.map { |m| m['createdDateTime'] }.compact.max
+            @channel_hwm[channel_id] = latest if latest
+          end
+
+          def filter_new_messages(channel_id:, messages:)
+            hwm = @channel_hwm[channel_id]
+            return messages unless hwm
+
+            messages.select { |m| m['createdDateTime'].to_s > hwm }
+          end
+
+          def log_message(team_name:, channel_name:, msg:)
+            sender  = msg.dig('from', 'user', 'displayName') || 'Unknown'
+            content = (msg.dig('body', 'content') || '').gsub(/<[^>]+>/, '').strip
+            snippet = content.length > 100 ? "#{content[0, 100]}..." : content
+            log_info("  [#{team_name}] ##{channel_name} | #{sender}: #{snippet}")
+          end
+
+          def max_teams
+            channel_setting(:max_teams, DEFAULT_MAX_TEAMS)
+          end
+
+          def max_channels_per_team
+            channel_setting(:max_channels_per_team, DEFAULT_MAX_CHANNELS)
+          end
+
+          def channel_setting(key, default)
+            return default unless defined?(Legion::Settings)
+
+            Legion::Settings.dig(:microsoft_teams, :channels, key) || default
+          rescue StandardError
+            default
+          end
+
+          def store_channel_message_trace(team_name:, channel_name:, msg:)
+            sender = msg.dig('from', 'user', 'displayName') || 'Unknown'
+            content = (msg.dig('body', 'content') || '').gsub(/<[^>]+>/, '').strip
+            memory_runner.store_trace(
+              type:            :episodic,
+              content_payload: "#{sender} in #{team_name}/##{channel_name}: #{content}"[0, 5000],
+              domain_tags:     ['teams', 'channel', "team:#{team_name}", "channel:#{channel_name}", "sender:#{sender}"],
+              origin:          :direct_experience,
+              confidence:      0.7
+            )
+          rescue StandardError => e
+            log_error("Failed to store channel message trace: #{e.message}")
+          end
+
+          def log_debug(msg)
+            Legion::Logging.debug("[Teams::ChannelPoller] #{msg}") if defined?(Legion::Logging)
+          end
+
+          def log_info(msg)
+            Legion::Logging.info("[Teams::ChannelPoller] #{msg}") if defined?(Legion::Logging)
+          end
+
+          def log_error(msg)
+            Legion::Logging.error("[Teams::ChannelPoller] #{msg}") if defined?(Legion::Logging)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -33,17 +33,22 @@ module Legion
           end
 
           def token_cache
-            @token_cache ||= Legion::Extensions::MicrosoftTeams::Helpers::TokenCache.new
+            Legion::Extensions::MicrosoftTeams::Helpers::TokenCache.instance
           end
 
           def manual
             token = token_cache.cached_graph_token
-            return unless token
+            unless token
+              log_debug('No token available, skipping poll')
+              return
+            end
 
+            log_info('Polling bot DM chats')
             chats = fetch_bot_chats(token: token)
+            log_info("Found #{chats.length} bot chats")
             chats.each { |chat| poll_chat(chat_id: chat[:id], token: token) }
           rescue StandardError => e
-            Legion::Logging.error("DirectChatPoller: #{e.message}") if defined?(Legion::Logging)
+            log_error("DirectChatPoller: #{e.message}")
           end
 
           private
@@ -64,6 +69,7 @@ module Legion
             new_msgs.reject! { |m| m[:from_id] == @bot_id }
             return if new_msgs.empty?
 
+            log_info("Chat #{chat_id}: #{new_msgs.length} new message(s)")
             new_msgs.each { |msg| publish_message(msg.merge(chat_id: chat_id, mode: :direct)) }
             update_hwm_from_messages(chat_id: chat_id, messages: new_msgs)
           end
@@ -71,7 +77,7 @@ module Legion
           def publish_message(payload)
             Legion::Extensions::MicrosoftTeams::Transport::Messages::TeamsMessage.new.publish(payload)
           rescue StandardError => e
-            Legion::Logging.error("DirectChatPoller publish failed: #{e.message}") if defined?(Legion::Logging)
+            log_error("DirectChatPoller publish failed: #{e.message}")
           end
 
           def normalize_messages(messages)
@@ -98,6 +104,18 @@ module Legion
 
             Legion::Settings.dig(:microsoft_teams, :bot, key) || default
           end
+
+          def log_debug(msg)
+            Legion::Logging.debug("[Teams::DirectChatPoller] #{msg}") if defined?(Legion::Logging)
+          end
+
+          def log_info(msg)
+            Legion::Logging.info("[Teams::DirectChatPoller] #{msg}") if defined?(Legion::Logging)
+          end
+
+          def log_error(msg)
+            Legion::Logging.error("[Teams::DirectChatPoller] #{msg}") if defined?(Legion::Logging)
+          end
         end
       end
     end

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

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module MicrosoftTeams
+      module Actor
+        class MeetingIngest < Legion::Extensions::Actors::Every
+          include Legion::Extensions::MicrosoftTeams::Helpers::Client
+
+          DEFAULT_INGEST_INTERVAL = 300
+
+          def runner_class    = Legion::Extensions::MicrosoftTeams::Helpers::TokenCache
+          def runner_function = 'cached_graph_token'
+          def run_now?        = false
+          def use_runner?     = false
+          def check_subtask?  = false
+          def generate_task?  = false
+
+          def initialize(**opts)
+            @processed_meetings = Set.new
+            super
+          end
+
+          def time
+            settings = begin
+              Legion::Settings[:microsoft_teams] || {}
+            rescue StandardError
+              {}
+            end
+            settings.dig(:meetings, :ingest_interval) || DEFAULT_INGEST_INTERVAL
+          end
+
+          def enabled?
+            defined?(Legion::Extensions::MicrosoftTeams::Helpers::TokenCache)
+          rescue StandardError
+            false
+          end
+
+          def memory_available?
+            defined?(Legion::Extensions::Agentic::Memory::Trace::Runners::Traces)
+          end
+
+          def memory_runner
+            @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_graph_token
+            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)")
+
+            meetings.each do |meeting|
+              meeting_id = meeting['id']
+              next if @processed_meetings.include?(meeting_id)
+
+              begin
+                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}")
+              end
+            end
+          rescue StandardError => e
+            log_error("MeetingIngest: #{e.message}")
+          end
+
+          private
+
+          def process_meeting(meeting_id:, subject:, token:)
+            conn = graph_connection(token: token)
+
+            transcripts = fetch_transcripts(conn: conn, meeting_id: meeting_id)
+            log_info("Meeting '#{subject}' (#{meeting_id}): #{transcripts.length} transcript(s)")
+
+            transcripts.each do |transcript|
+              fetch_and_log_transcript_content(
+                conn:       conn,
+                meeting_id: meeting_id,
+                subject:    subject,
+                token:      token,
+                transcript: transcript
+              )
+            end
+
+            fetch_and_log_ai_insights(conn: conn, meeting_id: meeting_id, subject: subject)
+          end
+
+          def fetch_transcripts(conn:, 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}")
+            []
+          end
+
+          def fetch_and_log_transcript_content(conn:, meeting_id:, subject:, token:, transcript:) # rubocop:disable Lint/UnusedMethodArgument
+            tid = transcript['id']
+            content_conn = graph_connection(token: token)
+            content_response = content_conn.get(
+              "#{user_path('me')}/onlineMeetings/#{meeting_id}/transcripts/#{tid}/content",
+              {},
+              { 'Accept' => 'text/vtt' }
+            )
+            content = content_response.body.to_s
+            preview = content[0, 200]
+            log_debug("Meeting '#{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}")
+          end
+
+          def fetch_and_log_ai_insights(conn:, meeting_id:, subject:)
+            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)")
+
+            insights.each do |insight|
+              action_items = insight['actionItems'] || []
+              next if action_items.empty?
+
+              log_info("Meeting '#{subject}' AI insight action items (#{action_items.length}):")
+              action_items.each do |item|
+                log_info("  - #{item['text'] || item.inspect}")
+              end
+
+              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}")
+          end
+
+          def store_transcript_trace(meeting_id:, subject:, transcript_id:, content:) # rubocop:disable Lint/UnusedMethodArgument
+            memory_runner.store_trace(
+              type:            :episodic,
+              content_payload: content[0, 10_000],
+              domain_tags:     ['teams', 'transcript', "meeting:#{meeting_id}", "transcript:#{transcript_id}"],
+              origin:          :direct_experience,
+              confidence:      0.9
+            )
+          rescue StandardError => e
+            log_warn("Could not store transcript trace for meeting #{meeting_id}: #{e.message}")
+          end
+
+          def store_insight_trace(meeting_id:, subject:, insight:) # rubocop:disable Lint/UnusedMethodArgument
+            memory_runner.store_trace(
+              type:            :semantic,
+              content_payload: insight.to_s,
+              domain_tags:     ['teams', 'ai-insight', "meeting:#{meeting_id}"],
+              origin:          :inferred,
+              confidence:      0.8
+            )
+          rescue StandardError => e
+            log_warn("Could not store insight trace for meeting #{meeting_id}: #{e.message}")
+          end
+
+          def log_debug(msg)
+            Legion::Logging.debug("[Teams::MeetingIngest] #{msg}") if defined?(Legion::Logging)
+          end
+
+          def log_info(msg)
+            Legion::Logging.info("[Teams::MeetingIngest] #{msg}") if defined?(Legion::Logging)
+          end
+
+          def log_warn(msg)
+            Legion::Logging.warn("[Teams::MeetingIngest] #{msg}") if defined?(Legion::Logging)
+          end
+
+          def log_error(msg)
+            Legion::Logging.error("[Teams::MeetingIngest] #{msg}") if defined?(Legion::Logging)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -6,7 +6,7 @@ module Legion
       module Actor
         class MessageProcessor < Legion::Extensions::Actors::Subscription
           def runner_class    = 'Legion::Extensions::MicrosoftTeams::Runners::Bot'
-          def runner_function = 'handle_message'
+          def runner_function = 'dispatch_message'
           def check_subtask?  = false
           def generate_task?  = false
 

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

@@ -35,7 +35,7 @@ module Legion
           end
 
           def token_cache
-            @token_cache ||= Legion::Extensions::MicrosoftTeams::Helpers::TokenCache.new
+            Legion::Extensions::MicrosoftTeams::Helpers::TokenCache.instance
           end
 
           def subscription_registry