lex-microsoft_teams 0.6.37 → 0.6.42

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 850930c48981007e5ba07fb8315bf3f5da8cb9eff02ca11911e3a531b820ca71
-  data.tar.gz: b199dce28d0301f690870ae99e9930a8b178a3842ce6800e3f4fc6d4134943e4
+  metadata.gz: b320641fa223ed514787d28161d2072d039da5a34ec81ab9cfe2f4289b5403ba
+  data.tar.gz: b13504e4b41e1ff97360a7a0cedea33989b9649798009a1f2bda16bcff312962
 SHA512:
-  metadata.gz: 998911159c181f88202dcd509fafb838adcbd2f1efd2368297ac20fa86cefdff591481986f7d063a69c5f4ffe3225a254ef70f4f6cc9a3f1e7c43080540bec59
-  data.tar.gz: 33ae5434516d523cf1433f0a387d00646a06ae364714a52fb467403b0e93094b41d42f68daf847f1c052e2845f273c2e8e87d5af43d3a74e6eb7aeeba1fa41f6
+  metadata.gz: 1064e76e545459d2e14c399b5610ede6e24fbb126a9c917806d992b6aa738e69fa27cc4ee6de50b8aec357f4fb53029c7c7f113e38d7cc720dd1c1a9f8879936
+  data.tar.gz: dff546a2489dc75715e2355c16237f4e1ad0f0677866c1f464f35791c3747ab70b7e31b692d3602680f57434c7d0529f099191c6b59f079a07353bdc9933299b

data/.rubocop.yml

@@ -16,3 +16,8 @@ Legion/Extension/EveryActorRequiresTime:
 # RunnerReturnHash fires on private helper methods inside runner modules (false positives)
 Legion/Extension/RunnerReturnHash:
   Enabled: false
+  
+Metrics/CyclomaticComplexity:
+  Max: 25
+Metrics/PerceivedComplexity:
+  Max: 25

data/CHANGELOG.md

@@ -2,6 +2,42 @@
 
 ## [Unreleased]
 
+## [0.6.42] - 2026-04-23
+
+### Fixed
+- `Helpers::TokenCache#vault_path` — replaced `ENV.fetch('USER', 'default')` with `Legion::Identity::Process.canonical_name` (the resolved Kerberos/LDAP identity), matching the pattern used in `legion-llm` PR #80. Falls back to `ENV['USER'].split('@').first` (email domain stripped) if Identity is not yet resolved
+- Also removed the `microsoft_teams` namespace segment from the returned suffix — `Crypt::Helper#vault_write` wraps the path in its own `vault_path(suffix)` which already prepends the lex namespace, so including it again caused double-prefixed Vault paths (`microsoft_teams/users/.../microsoft_teams/delegated_token`).
+- Final Vault path is now: `microsoft_teams/users/{canonical_name}/delegated_token`
+- Configurable via `settings[:auth][:delegated][:vault_path]` if a custom path is needed
+
+## [0.6.41] - 2026-04-23
+
+### Fixed
+- `Helpers::Client#graph_connection` and `#bot_connection` — replaced `Legion::Settings[:microsoft_teams]` with `settings` (provided by `Legion::Settings::Helper` via `Helpers::Lex`), which correctly scopes to the lex key automatically and is the approved pattern inside a lex
+- `Helpers::TokenCache#teams_auth_settings` — same fix; replaced `Legion::Settings[:microsoft_teams]` with `settings`, removed the now-redundant `defined?(Legion::Settings)` guard and `if ms` nil guards (settings always returns a Hash)
+- The only remaining `Legion::Settings` references in `token_cache.rb` are for cross-lex lookups (`:crypt, :vault, :connected`) which are intentional and correct
+- Token write paths (`save_to_local`, `save_to_vault`) confirmed clean — write to `local_token_path` (defaulting to `~/.legionio/tokens/`) and Vault respectively, not into settings
+
+## [0.6.40] - 2026-04-23
+
+### Fixed
+- `Helpers::BrowserAuth` — removed private `log` method that was shadowing the `log` accessor provided by `Legion::Extensions::Helpers::Lex`. The `include Helpers::Lex` guard was already present but the manual fallback overrode it; all `log.debug/info/warn/error` calls now correctly route through the Lex helper (structured logging, context propagation, etc.)
+
+## [0.6.39] - 2026-04-23
+
+### Added
+- `Absorbers::Chat` — absorbs a Teams chat thread into Apollo by URL (`teams.microsoft.com/l/chat/19:*@*`). Extracts the chat ID from the URL, fetches metadata, pulls messages (with inline replies, HTML stripped), and ingests participants. Content types: `teams_chat_thread`, `teams_chat_participants`
+- `Absorbers::Channel` — absorbs a Teams channel or specific thread into Apollo by URL (`teams.microsoft.com/l/channel/*`, `teams.microsoft.com/l/message/*`). Extracts `team_id` from `groupId` query param and `channel_id` from path. When a `message_id` is present (deep-link to a specific thread) only that thread is ingested; otherwise the top 50 channel messages are ingested. Replies are fetched and inlined. Content types: `teams_channel_thread`, `teams_channel_members`
+- `Actors::AbsorbChat` — Subscription actor delegating to `Absorbers::Chat#absorb`, mirrors the `AbsorbMeeting` actor pattern
+- `Actors::AbsorbChannel` — Subscription actor delegating to `Absorbers::Channel#absorb`, mirrors the `AbsorbMeeting` actor pattern
+- Both new absorbers and actors are conditionally required (gated on `Legion::Extensions::Absorbers::Base` presence) in `microsoft_teams.rb`
+
+## [0.6.38] - 2026-04-23
+
+### Fixed
+- `Helpers::Client#graph_connection` now falls back to `Legion::Settings[:microsoft_teams]&.dig(:auth, :delegated, :token)` when no `token:` is explicitly passed — fixes unauthenticated Graph API calls when runners are invoked as standalone modules via Lex tool dispatch (not via an instantiated `Client` object where `@opts` carries the token)
+- `Helpers::Client#bot_connection` applies the same fallback using `Legion::Settings[:microsoft_teams]&.dig(:auth, :bot, :token)`
+
 ## [0.7.0] - unreleased
 
 ### Added

data/lib/legion/extensions/microsoft_teams/absorbers/channel.rb

@@ -0,0 +1,226 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module MicrosoftTeams
+      module Absorbers
+        class Channel < Legion::Extensions::Absorbers::Base
+          pattern :url, 'teams.microsoft.com/l/channel/*'
+          pattern :url, 'teams.microsoft.com/l/message/*'
+          description 'Absorbs a Teams channel thread (messages, replies, members) into Apollo'
+
+          def absorb(url: nil, content: nil, metadata: {}, context: {}) # rubocop:disable Lint/UnusedMethodArgument
+            report_progress(message: 'extracting ids from url')
+            ids = extract_ids(url)
+            return { success: false, error: 'could not extract team/channel ids from url' } unless ids
+
+            team_id    = ids[:team_id]
+            channel_id = ids[:channel_id]
+            message_id = ids[:message_id]
+
+            report_progress(message: 'fetching channel metadata', percent: 10)
+            channel = resolve_channel(team_id, channel_id)
+            return { success: false, error: 'could not resolve channel' } unless channel
+
+            channel_name = channel['displayName'] || channel[:displayName] || 'untitled channel'
+            results = { team_id: team_id, channel_id: channel_id, channel_name: channel_name, chunks: 0 }
+
+            if message_id
+              # Scoped to a specific thread
+              ingest_thread(team_id, channel_id, message_id, channel_name, results)
+            else
+              # Full channel ingest
+              ingest_messages(team_id, channel_id, channel_name, results)
+            end
+
+            ingest_members(team_id, channel_id, channel_name, results)
+
+            report_progress(message: 'done', percent: 100)
+            results.merge(success: true)
+          rescue StandardError => e
+            log.error("Channel absorber failed: #{e.message}")
+            { success: false, error: e.message }
+          end
+
+          private
+
+          def channels_runner
+            @channels_runner ||= Object.new.extend(Runners::Channels)
+          end
+
+          def channel_messages_runner
+            @channel_messages_runner ||= Object.new.extend(Runners::ChannelMessages)
+          end
+
+          def graph_token
+            return @graph_token if defined?(@graph_token)
+
+            @graph_token = begin
+              Helpers::TokenCache.instance.cached_delegated_token if defined?(Helpers::TokenCache)
+            rescue StandardError => e
+              log.warn("graph_token unavailable: #{e.message}")
+              nil
+            end
+          end
+
+          # Teams channel URL formats:
+          #   /l/channel/<encoded_channel_id>/<channel_name>?groupId=<team_id>&...
+          #   /l/message/<encoded_channel_id>/<message_id>?groupId=<team_id>&...
+          def extract_ids(url)
+            return nil unless url.is_a?(String)
+
+            uri    = URI.parse(url)
+            params = URI.decode_www_form(uri.query.to_s).to_h
+
+            team_id    = params['groupId'] || params['groupid']
+            return nil unless team_id
+
+            path_parts = uri.path.split('/')
+            # path: ["", "l", "channel"|"message", <encoded_id>, ...]
+            encoded_id = path_parts[3]
+            return nil unless encoded_id
+
+            channel_id = URI.decode_uri_component(encoded_id)
+
+            message_id = (path_parts[4] if uri.path.include?('/l/message/'))
+
+            { team_id: team_id, channel_id: channel_id, message_id: message_id }
+          rescue StandardError => e
+            log.debug("extract_ids failed: #{e.message}")
+            nil
+          end
+
+          def resolve_channel(team_id, channel_id)
+            response = channels_runner.get_channel(team_id: team_id, channel_id: channel_id, token: graph_token)
+            body = response.is_a?(Hash) ? response[:result] : nil
+            return nil unless body.is_a?(Hash) && !body['error'] && !body[:error]
+
+            body
+          rescue StandardError => e
+            log.warn("resolve_channel failed: #{e.message}")
+            nil
+          end
+
+          def ingest_messages(team_id, channel_id, channel_name, results)
+            report_progress(message: 'fetching channel messages', percent: 25)
+            response = channel_messages_runner.list_channel_messages(
+              team_id: team_id, channel_id: channel_id, top: 50, token: graph_token
+            )
+            body  = response.is_a?(Hash) ? response[:result] : nil
+            items = body.is_a?(Hash) ? (body['value'] || body[:value]) : nil
+            return unless items.is_a?(Array) && items.any?
+
+            items.reverse_each do |msg|
+              ingest_single_message(team_id, channel_id, msg, channel_name, results)
+            end
+          rescue StandardError => e
+            log.warn("Channel message ingest failed: #{e.message}")
+          end
+
+          def ingest_thread(team_id, channel_id, message_id, channel_name, results)
+            report_progress(message: 'fetching thread root message', percent: 20)
+            response = channel_messages_runner.get_channel_message(
+              team_id: team_id, channel_id: channel_id, message_id: message_id, token: graph_token
+            )
+            body = response.is_a?(Hash) ? response[:result] : nil
+            return unless body.is_a?(Hash) && !body['error']
+
+            ingest_single_message(team_id, channel_id, body, channel_name, results, scoped_thread: true)
+          rescue StandardError => e
+            log.warn("Thread ingest failed: #{e.message}")
+          end
+
+          def ingest_single_message(team_id, channel_id, msg, channel_name, results, scoped_thread: false)
+            return unless msg.is_a?(Hash)
+            return if msg['deletedDateTime'] || msg[:deletedDateTime]
+            return if (msg['messageType'] || msg[:messageType]) == 'unknownFutureValue'
+
+            msg_id       = msg['id'] || msg[:id]
+            sender       = msg.dig('from', 'user', 'displayName') ||
+                           msg.dig(:from, :user, :displayName) ||
+                           'unknown'
+            body_content = msg.dig('body', 'content') || msg.dig(:body, :content) || ''
+            text         = body_content.gsub(/<[^>]+>/, '').strip
+            return if text.empty? && !scoped_thread
+
+            subject   = msg['subject'] || msg[:subject]
+            timestamp = msg['createdDateTime'] || msg[:createdDateTime]
+            lines     = []
+            lines << "Subject: #{subject}" if subject && !subject.empty?
+            lines << "[#{timestamp}] #{sender}: #{text}" unless text.empty?
+
+            reply_lines = fetch_reply_lines(team_id, channel_id, msg_id)
+            lines.concat(reply_lines)
+
+            return if lines.empty?
+
+            percent = scoped_thread ? 60 : nil
+            report_progress(message: "ingesting message #{msg_id}", percent: percent) if percent
+
+            absorb_to_knowledge(
+              content:      lines.join("\n"),
+              tags:         ['teams', 'channel', 'thread', channel_name],
+              source_file:  "teams://teams/#{team_id}/channels/#{channel_id}/messages/#{msg_id}",
+              heading:      "Channel Thread: #{channel_name}#{" — #{subject}" if subject}",
+              content_type: 'teams_channel_thread'
+            )
+            results[:chunks] += 1
+          rescue StandardError => e
+            log.warn("ingest_single_message failed: #{e.message}")
+          end
+
+          def fetch_reply_lines(team_id, channel_id, message_id)
+            return [] unless message_id
+
+            response = channel_messages_runner.list_channel_message_replies(
+              team_id: team_id, channel_id: channel_id, message_id: message_id, top: 50, token: graph_token
+            )
+            body  = response.is_a?(Hash) ? response[:result] : nil
+            items = body.is_a?(Hash) ? (body['value'] || body[:value]) : nil
+            return [] unless items.is_a?(Array) && items.any?
+
+            items.filter_map do |reply|
+              next if reply['deletedDateTime'] || reply[:deletedDateTime]
+
+              sender       = reply.dig('from', 'user', 'displayName') ||
+                             reply.dig(:from, :user, :displayName) ||
+                             'unknown'
+              body_content = reply.dig('body', 'content') || reply.dig(:body, :content) || ''
+              text         = body_content.gsub(/<[^>]+>/, '').strip
+              next if text.empty?
+
+              timestamp = reply['createdDateTime'] || reply[:createdDateTime]
+              "  ↳ [#{timestamp}] #{sender}: #{text}"
+            end
+          rescue StandardError => e
+            log.debug("fetch_reply_lines failed: #{e.message}")
+            []
+          end
+
+          def ingest_members(team_id, channel_id, channel_name, results)
+            report_progress(message: 'fetching channel members', percent: 85)
+            response = channels_runner.list_channel_members(
+              team_id: team_id, channel_id: channel_id, token: graph_token
+            )
+            body  = response.is_a?(Hash) ? response[:result] : nil
+            items = body.is_a?(Hash) ? (body['value'] || body[:value]) : nil
+            return unless items.is_a?(Array) && items.any?
+
+            names = items.filter_map { |m| m['displayName'] || m[:displayName] }
+            return if names.empty?
+
+            absorb_raw(
+              content:      "Channel members for '#{channel_name}': #{names.join(', ')}",
+              tags:         ['teams', 'channel', 'members', channel_name],
+              content_type: 'teams_channel_members',
+              metadata:     { team_id: team_id, channel_id: channel_id, member_count: names.length }
+            )
+            results[:chunks] += 1
+          rescue StandardError => e
+            log.warn("Member ingest failed: #{e.message}")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/microsoft_teams/absorbers/chat.rb

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module MicrosoftTeams
+      module Absorbers
+        class Chat < Legion::Extensions::Absorbers::Base
+          pattern :url, 'teams.microsoft.com/l/chat/19:*@*'
+          pattern :url, 'teams.microsoft.com/l/chat/19:*_*@*'
+          description 'Absorbs a Teams chat thread (messages, replies, participants) into Apollo'
+
+          def absorb(url: nil, content: nil, metadata: {}, context: {}) # rubocop:disable Lint/UnusedMethodArgument
+            report_progress(message: 'extracting chat id from url')
+            chat_id = extract_chat_id(url)
+            return { success: false, error: 'could not extract chat id from url' } unless chat_id
+
+            report_progress(message: 'fetching chat metadata', percent: 10)
+            chat = resolve_chat(chat_id)
+            return { success: false, error: 'could not resolve chat' } unless chat
+
+            topic = chat['topic'] || chat[:topic] || 'untitled chat'
+            results = { chat_id: chat_id, topic: topic, chunks: 0 }
+
+            ingest_messages(chat_id, topic, results)
+            ingest_members(chat_id, topic, results)
+
+            report_progress(message: 'done', percent: 100)
+            results.merge(success: true)
+          rescue StandardError => e
+            log.error("Chat absorber failed: #{e.message}")
+            { success: false, error: e.message }
+          end
+
+          private
+
+          def chats_runner
+            @chats_runner ||= Object.new.extend(Runners::Chats)
+          end
+
+          def messages_runner
+            @messages_runner ||= Object.new.extend(Runners::Messages)
+          end
+
+          def graph_token
+            return @graph_token if defined?(@graph_token)
+
+            @graph_token = begin
+              Helpers::TokenCache.instance.cached_delegated_token if defined?(Helpers::TokenCache)
+            rescue StandardError => e
+              log.warn("graph_token unavailable: #{e.message}")
+              nil
+            end
+          end
+
+          def extract_chat_id(url)
+            return nil unless url.is_a?(String)
+
+            # teams.microsoft.com/l/chat/19:XXXXX@unq.gbl.spaces/...
+            match = url.match(%r{/l/chat/(19:[^/?#]+)})
+            return unless match
+
+            URI.decode_uri_component(match[1])
+          rescue StandardError => e
+            log.debug("extract_chat_id failed: #{e.message}")
+            nil
+          end
+
+          def resolve_chat(chat_id)
+            response = chats_runner.get_chat(chat_id: chat_id, token: graph_token)
+            body = response.is_a?(Hash) ? response[:result] : nil
+            return nil unless body.is_a?(Hash) && !body['error'] && !body[:error]
+
+            body
+          rescue StandardError => e
+            log.warn("resolve_chat failed: #{e.message}")
+            nil
+          end
+
+          def ingest_messages(chat_id, topic, results)
+            report_progress(message: 'fetching messages', percent: 25)
+            response = messages_runner.list_chat_messages(chat_id: chat_id, top: 50, token: graph_token)
+            body = response.is_a?(Hash) ? response[:result] : nil
+            return unless body.is_a?(Hash)
+
+            items = body['value'] || body[:value]
+            return unless items.is_a?(Array) && items.any?
+
+            # Filter out system/deleted messages and build a readable transcript
+            lines = []
+            items.reverse_each do |msg|
+              next if msg['messageType'] != 'message' && !msg['messageType'].nil?
+              next if msg['deletedDateTime'] || msg[:deletedDateTime]
+
+              sender = msg.dig('from', 'user', 'displayName') ||
+                       msg.dig(:from, :user, :displayName) ||
+                       'unknown'
+              body_content = msg.dig('body', 'content') || msg.dig(:body, :content) || ''
+              # Strip HTML tags for plain text
+              text = body_content.gsub(/<[^>]+>/, '').strip
+              next if text.empty?
+
+              timestamp = msg['createdDateTime'] || msg[:createdDateTime]
+              lines << "[#{timestamp}] #{sender}: #{text}"
+
+              # Pull replies for this message
+              reply_lines = fetch_reply_lines(chat_id, msg['id'] || msg[:id], topic)
+              lines.concat(reply_lines) if reply_lines.any?
+            end
+
+            return if lines.empty?
+
+            report_progress(message: 'ingesting message thread', percent: 60)
+            absorb_to_knowledge(
+              content:      lines.join("\n"),
+              tags:         ['teams', 'chat', 'messages', topic],
+              source_file:  "teams://chats/#{chat_id}/messages",
+              heading:      "Chat: #{topic}",
+              content_type: 'teams_chat_thread'
+            )
+            results[:chunks] += 1
+          rescue StandardError => e
+            log.warn("Message ingest failed: #{e.message}")
+          end
+
+          def fetch_reply_lines(chat_id, message_id, _topic)
+            return [] unless message_id
+
+            response = messages_runner.list_message_replies(
+              chat_id: chat_id, message_id: message_id, top: 50, token: graph_token
+            )
+            body  = response.is_a?(Hash) ? response[:result] : nil
+            items = body.is_a?(Hash) ? (body['value'] || body[:value]) : nil
+            return [] unless items.is_a?(Array) && items.any?
+
+            items.filter_map do |reply|
+              next if reply['deletedDateTime'] || reply[:deletedDateTime]
+
+              sender       = reply.dig('from', 'user', 'displayName') ||
+                             reply.dig(:from, :user, :displayName) ||
+                             'unknown'
+              body_content = reply.dig('body', 'content') || reply.dig(:body, :content) || ''
+              text         = body_content.gsub(/<[^>]+>/, '').strip
+              next if text.empty?
+
+              timestamp = reply['createdDateTime'] || reply[:createdDateTime]
+              "  ↳ [#{timestamp}] #{sender}: #{text}"
+            end
+          rescue StandardError => e
+            log.debug("fetch_reply_lines failed: #{e.message}")
+            []
+          end
+
+          def ingest_members(chat_id, topic, results)
+            report_progress(message: 'fetching members', percent: 80)
+            response = chats_runner.list_chat_members(chat_id: chat_id, token: graph_token)
+            body = response.is_a?(Hash) ? response[:result] : nil
+            return unless body.is_a?(Hash)
+
+            items = body['value'] || body[:value]
+            return unless items.is_a?(Array) && items.any?
+
+            names = items.filter_map do |m|
+              m['displayName'] || m[:displayName]
+            end
+            return if names.empty?
+
+            absorb_raw(
+              content:      "Chat participants for '#{topic}': #{names.join(', ')}",
+              tags:         ['teams', 'chat', 'participants', topic],
+              content_type: 'teams_chat_participants',
+              metadata:     { chat_id: chat_id, participant_count: names.length }
+            )
+            results[:chunks] += 1
+          rescue StandardError => e
+            log.warn("Member ingest failed: #{e.message}")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module MicrosoftTeams
+      module Actor
+        class AbsorbChannel < Legion::Extensions::Actors::Subscription
+          def runner_class    = 'Legion::Extensions::MicrosoftTeams::Absorbers::Channel'
+          def runner_function = 'absorb'
+          def check_subtask?  = false
+          def generate_task?  = false
+
+          def enabled?
+            defined?(Legion::Extensions::Absorbers::Base) &&
+              defined?(Legion::Extensions::MicrosoftTeams::Absorbers::Channel)
+          rescue StandardError => e
+            log.debug("AbsorbChannel#enabled?: #{e.message}")
+            false
+          end
+
+          def work(payload)
+            parsed   = parse_payload(payload)
+            absorber = Absorbers::Channel.new
+            result   = absorber.absorb(
+              url:      parsed[:url],
+              metadata: parsed[:metadata] || {},
+              context:  parsed[:context] || {}
+            )
+            if result.respond_to?(:[]) && result.key?(:success)
+              if result[:success]
+                ack!
+              else
+                log.error("AbsorbChannel actor absorb failed: #{result.inspect}")
+                reject!(requeue: false)
+              end
+            else
+              ack!
+            end
+            result
+          rescue StandardError => e
+            log.error("AbsorbChannel actor error: #{e.message}")
+            reject!(requeue: false)
+          end
+
+          private
+
+          def parse_payload(payload)
+            data = payload.is_a?(String) ? json_load(payload) : payload
+            return {} unless data.is_a?(Hash)
+
+            data.transform_keys(&:to_sym)
+          rescue StandardError => e
+            log.debug("AbsorbChannel#parse_payload: #{e.message}")
+            {}
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module MicrosoftTeams
+      module Actor
+        class AbsorbChat < Legion::Extensions::Actors::Subscription
+          def runner_class    = 'Legion::Extensions::MicrosoftTeams::Absorbers::Chat'
+          def runner_function = 'absorb'
+          def check_subtask?  = false
+          def generate_task?  = false
+
+          def enabled?
+            defined?(Legion::Extensions::Absorbers::Base) &&
+              defined?(Legion::Extensions::MicrosoftTeams::Absorbers::Chat)
+          rescue StandardError => e
+            log.debug("AbsorbChat#enabled?: #{e.message}")
+            false
+          end
+
+          def work(payload)
+            parsed   = parse_payload(payload)
+            absorber = Absorbers::Chat.new
+            result   = absorber.absorb(
+              url:      parsed[:url],
+              metadata: parsed[:metadata] || {},
+              context:  parsed[:context] || {}
+            )
+            if result.respond_to?(:[]) && result.key?(:success)
+              if result[:success]
+                ack!
+              else
+                log.error("AbsorbChat actor absorb failed: #{result.inspect}")
+                reject!(requeue: false)
+              end
+            else
+              ack!
+            end
+            result
+          rescue StandardError => e
+            log.error("AbsorbChat actor error: #{e.message}")
+            reject!(requeue: false)
+          end
+
+          private
+
+          def parse_payload(payload)
+            data = payload.is_a?(String) ? json_load(payload) : payload
+            return {} unless data.is_a?(Hash)
+
+            data.transform_keys(&:to_sym)
+          rescue StandardError => e
+            log.debug("AbsorbChat#parse_payload: #{e.message}")
+            {}
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -106,14 +106,6 @@ module Legion
 
           private
 
-          def log
-            return Legion::Logging if defined?(Legion::Logging) # rubocop:disable Legion/HelperMigration/LoggingGuard
-
-            @log ||= Object.new.tap do |nl|
-              %i[debug info warn error fatal].each { |m| nl.define_singleton_method(m) { |*| nil } }
-            end
-          end
-
           def host_os
             RbConfig::CONFIG['host_os']
           end

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

@@ -7,7 +7,11 @@ module Legion
     module MicrosoftTeams
       module Helpers
         module Client
+          include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers, false) &&
+                                                      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)
             Faraday.new(url: api_url) do |conn|
               conn.request :json
               conn.response :json, content_type: /\bjson$/
@@ -17,6 +21,7 @@ module Legion
           end
 
           def bot_connection(token: nil, service_url: 'https://smba.trafficmanager.net/teams/', **_opts)
+            token ||= settings&.dig(:auth, :bot, :token)
             Faraday.new(url: service_url) do |conn|
               conn.request :json
               conn.response :json, content_type: /\bjson$/

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

@@ -277,8 +277,14 @@ module Legion
           def vault_path(_suffix = nil)
             settings = teams_auth_settings
             delegated = settings[:delegated]
-            custom = delegated[:vault_path] if delegated.is_a?(Hash)
-            custom || "users/#{ENV.fetch('USER', 'default')}/microsoft_teams/delegated_token"
+            return delegated[:vault_path] if delegated.is_a?(Hash) && delegated[:vault_path]
+
+            identity = if defined?(Legion::Identity::Process) && Legion::Identity::Process.resolved?
+                         Legion::Identity::Process.canonical_name
+                       else
+                         ENV.fetch('USER', 'default').split('@').first
+                       end
+            "users/#{identity}/delegated_token"
           end
 
           def local_token_path
@@ -387,13 +393,11 @@ module Legion
           end
 
           def teams_auth_settings
-            return {} unless defined?(Legion::Settings)
-
-            ms = Legion::Settings[:microsoft_teams]
-            auth = ms && ms[:auth].is_a?(Hash) ? ms[:auth].dup : {}
-            auth[:tenant_id] ||= ms[:tenant_id] if ms
-            auth[:client_id] ||= ms[:client_id] if ms
-            auth[:client_secret] ||= ms[:client_secret] if ms
+            ms = settings
+            auth = ms[:auth].is_a?(Hash) ? ms[:auth].dup : {}
+            auth[:tenant_id] ||= ms[:tenant_id]
+            auth[:client_id] ||= ms[:client_id]
+            auth[:client_secret] ||= ms[:client_secret]
             auth[:tenant_id] ||= ENV.fetch('AZURE_TENANT_ID', nil)
             auth[:client_id] ||= ENV.fetch('AZURE_CLIENT_ID', nil)
             auth[:client_secret] ||= ENV.fetch('AZURE_CLIENT_SECRET', nil)

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

@@ -143,7 +143,7 @@ module Legion
 
           # Extract individual messages from a messageMap record.
           # These contain multiple messages in a reply chain.
-          def extract_message_map(strings, messages, seen_hashes) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+          def extract_message_map(strings, messages, seen_hashes)
             conversation_id = nil
             i = 0
 
@@ -232,7 +232,7 @@ module Legion
             )
           end
 
-          def apply_filters(messages, since:, channels:, senders:, skip_bots:) # rubocop:disable Metrics/CyclomaticComplexity
+          def apply_filters(messages, since:, channels:, senders:, skip_bots:)
             messages.select do |msg|
               next false if since && msg.compose_time && Time.parse(msg.compose_time) < since
               next false if channels&.none? { |c| msg.thread_topic&.downcase&.include?(c.downcase) }

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

@@ -21,7 +21,7 @@ module Legion
           # (same format as CacheIngest) with dedup by content hash.
           #
           # Requires a delegated token with Chat.Read and People.Read scopes.
-          def ingest_api(token:, top_people: 15, message_depth: 50, skip_bots: true, imprint_active: false, **) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
+          def ingest_api(token:, top_people: 15, message_depth: 50, skip_bots: true, imprint_active: false, **) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
             return error_result('lex-memory not loaded') unless memory_available?
             return error_result('no token provided') unless token && !token.empty?
 

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

@@ -3,7 +3,7 @@
 module Legion
   module Extensions
     module MicrosoftTeams
-      VERSION = '0.6.37'
+      VERSION = '0.6.42'
     end
   end
 end

data/lib/legion/extensions/microsoft_teams.rb

@@ -48,6 +48,8 @@ if defined?(Legion::Extensions) &&
    Legion::Extensions.const_defined?(:Absorbers, false) &&
    Legion::Extensions::Absorbers.const_defined?(:Base, false)
   require_relative 'microsoft_teams/absorbers/meeting'
+  require_relative 'microsoft_teams/absorbers/chat'
+  require_relative 'microsoft_teams/absorbers/channel'
 end
 
 module Legion

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-microsoft_teams
 version: !ruby/object:Gem::Version
-  version: 0.6.37
+  version: 0.6.42
 platform: ruby
 authors:
 - Esity
@@ -175,7 +175,11 @@ files:
 - docs/plans/2026-03-19-teams-token-lifecycle-implementation.md
 - lex-microsoft_teams.gemspec
 - lib/legion/extensions/microsoft_teams.rb
+- lib/legion/extensions/microsoft_teams/absorbers/channel.rb
+- lib/legion/extensions/microsoft_teams/absorbers/chat.rb
 - lib/legion/extensions/microsoft_teams/absorbers/meeting.rb
+- lib/legion/extensions/microsoft_teams/actors/absorb_channel.rb
+- lib/legion/extensions/microsoft_teams/actors/absorb_chat.rb
 - lib/legion/extensions/microsoft_teams/actors/absorb_meeting.rb
 - lib/legion/extensions/microsoft_teams/actors/api_ingest.rb
 - lib/legion/extensions/microsoft_teams/actors/auth_validator.rb