lex-microsoft_teams 0.6.36 → 0.6.40

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 82da6ce40d44d7e0db48fa308c66744d08e9c3acef735947b0a7eaffcc43d779
-  data.tar.gz: 49350f0fae7ae8d5abb60c37939de50d514bda4644f9c916116b98096ed7a7d6
+  metadata.gz: f6f9d39d6ddf7f53a0d22f727e6ca9cfede2aa3487cef4c8ffee064b549a158c
+  data.tar.gz: efbe44cedda75981daae45b173f795c968f2883e17d8526b512c0324a9269e73
 SHA512:
-  metadata.gz: 2caec65f224e1d07e9a723d01ba087b7b287f105b679786a76d526a8e984e461b355156ea62e54f65ed8c2579190242aa2ecb971c26c0af23128889dda1c22e1
-  data.tar.gz: ed7b550be8e342a45e0f059847a08cf12c4356d30a60ff33e02ac055eb0b2ddbdbca53dc9a1f80fb27a65fb19c21ef93a7727d4820df50243afaf72b06f22cc6
+  metadata.gz: 2147849085641ca61d971a3f7b37009a481285cf9edb1dead731d03f6007dac3845168d2aeeb19f6737cd8673144e0673b860e924676136b7c6213ef61240114
+  data.tar.gz: 297f2da23ebd6a9db658ca27eecb1504376cee05745f4dea3e5b9b5d4a29d33923c28375a766b99de9a5e58d935dc6688c3552cb55442514b4a187085335f7a2

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,37 @@
 
 ## [Unreleased]
 
+## [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
+- New `Runners::Loop` module with four functions for Microsoft Loop component support via `fluidEmbedCard`:
+  - `create_loop_file` — Creates a new `.loop` file in a user's OneDrive via the Graph API; returns drive item metadata including `webUrl`
+  - `loop_attachment` — Builds the `fluidEmbedCard` + placeholder attachment pair required to embed a Loop component in a Teams message
+  - `post_loop_to_chat` — Posts a Loop component inline into a Teams chat thread
+  - `post_loop_to_channel` — Posts a Loop component inline into a Teams channel thread
+- Requires `Files.ReadWrite` and `Sites.ReadWrite.All` Graph API permissions for `create_loop_file`; `Chat.ReadWrite` and `ChannelMessage.Send` are already required by existing runners
+- **Note:** Programmatic write access to Loop page *content* (Fluid Framework) is not yet available via Microsoft Graph; Loop files must be opened in Teams to initialize the collaborative session
+
 ## [0.6.36] - 2026-04-13
 
 ### Fixed

data/README.md

@@ -113,6 +113,14 @@ gem install lex-microsoft_teams
 - `action_submit` — Create a Submit action
 - `message_attachment` — Wrap a card as a message attachment
 
+### Loop Components
+- `create_loop_file` — Create a new `.loop` file in a user's OneDrive; returns drive item metadata including `webUrl`
+- `loop_attachment` — Build a `fluidEmbedCard` attachment array for embedding an existing Loop component URL in a Teams message
+- `post_loop_to_chat` — Post a Loop component inline into a Teams chat thread
+- `post_loop_to_channel` — Post a Loop component inline into a Teams channel thread
+
+> **Note:** Creating a `.loop` file provisions the OneDrive item; the Fluid Framework collaborative session is initialized by Teams on first open. Programmatic write access to Loop page *content* is not yet available via Microsoft Graph.
+
 ### Bot Framework
 - `send_activity` — Send an activity to a conversation
 - `reply_to_activity` — Reply to an existing activity

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/client.rb

@@ -15,6 +15,7 @@ require 'legion/extensions/microsoft_teams/runners/meetings'
 require 'legion/extensions/microsoft_teams/runners/transcripts'
 require 'legion/extensions/microsoft_teams/runners/people'
 require 'legion/extensions/microsoft_teams/runners/ownership'
+require 'legion/extensions/microsoft_teams/runners/loop'
 
 module Legion
   module Extensions
@@ -37,6 +38,7 @@ module Legion
         include Runners::CacheIngest
         include Runners::People
         include Runners::Ownership
+        include Runners::Loop
 
         attr_reader :opts
 

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

@@ -8,6 +8,7 @@ module Legion
       module Helpers
         module Client
           def graph_connection(token: nil, api_url: 'https://graph.microsoft.com/v1.0', **_opts)
+            token ||= Legion::Settings[:microsoft_teams]&.dig(:auth, :delegated, :token)
             Faraday.new(url: api_url) do |conn|
               conn.request :json
               conn.response :json, content_type: /\bjson$/
@@ -17,6 +18,7 @@ module Legion
           end
 
           def bot_connection(token: nil, service_url: 'https://smba.trafficmanager.net/teams/', **_opts)
+            token ||= Legion::Settings[:microsoft_teams]&.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/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/runners/loop.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+require 'legion/extensions/microsoft_teams/helpers/client'
+
+module Legion
+  module Extensions
+    module MicrosoftTeams
+      module Runners
+        module Loop
+          include Legion::Extensions::MicrosoftTeams::Helpers::Client
+          include Legion::JSON::Helper
+
+          # Creates a new .loop file in the user's OneDrive via the Graph API.
+          # The Fluid Framework collaborative session is initialized by Teams on first open.
+          # Returns the drive item metadata including +webUrl+, which can be passed to
+          # +post_loop_to_chat+ or +post_loop_to_channel+.
+          #
+          # @param filename     [String] Name of the file (e.g. "incident-status" or "incident-status.loop")
+          # @param folder_path  [String] OneDrive folder path relative to root (default: root)
+          # @param user_id      [String] Graph user ID or 'me' (default: 'me')
+          def create_loop_file(filename:, folder_path: nil, user_id: 'me', **)
+            filename = "#{filename}.loop" unless filename.end_with?('.loop')
+
+            path = if folder_path.nil? || folder_path.empty?
+                     "users/#{user_id}/drive/root:/#{filename}:/content"
+                   else
+                     "users/#{user_id}/drive/root:/#{folder_path}/#{filename}:/content"
+                   end
+
+            response = graph_connection(**).put(path, '', 'Content-Type' => 'application/octet-stream')
+            { result: response.body }
+          end
+
+          # Builds the fluidEmbedCard attachment array required to embed a Loop component
+          # in a Teams message. Pass the resulting array as +attachments:+ to
+          # +send_chat_message+ / +send_channel_message+, or use the convenience methods
+          # +post_loop_to_chat+ and +post_loop_to_channel+.
+          #
+          # @param component_url [String] SharePoint/OneDrive URL of the .loop file
+          #                               (the +webUrl+ from +create_loop_file+)
+          # @param source_type   [String] 'Compose' (default) or 'Loop'
+          def loop_attachment(component_url:, source_type: 'Compose', **)
+            attachment_id = SecureRandom.hex(16)
+            {
+              result: [
+                {
+                  id:          attachment_id,
+                  contentType: 'application/vnd.microsoft.card.fluidEmbedCard',
+                  contentUrl:  nil,
+                  content:     json_generate({ componentUrl: component_url, sourceType: source_type }),
+                  teamsAppId:  'FluidEmbedCard'
+                },
+                {
+                  id:          'placeholderCard',
+                  contentType: 'application/vnd.microsoft.card.codesnippet',
+                  content:     '{}',
+                  teamsAppId:  'FLUID_PLACEHOLDER_CARD'
+                }
+              ]
+            }
+          end
+
+          # Posts a message into a Teams chat thread with a Loop component embedded inline.
+          #
+          # @param chat_id       [String] Teams chat thread ID (e.g. 19:...@thread.v2)
+          # @param component_url [String] SharePoint/OneDrive URL of the .loop file
+          # @param body_text     [String] Optional plain-text preamble shown above the component
+          def post_loop_to_chat(chat_id:, component_url:, body_text: '', **)
+            attachments = loop_attachment(component_url: component_url, **)[:result]
+            content     = body_text.empty? ? '<p></p>' : "<p>#{body_text}</p>"
+            payload     = { body: { contentType: 'html', content: content }, attachments: attachments }
+            response    = graph_connection(**).post("chats/#{chat_id}/messages", payload)
+            { result: response.body }
+          end
+
+          # Posts a message into a Teams channel thread with a Loop component embedded inline.
+          #
+          # @param team_id       [String] Teams team ID
+          # @param channel_id    [String] Teams channel ID
+          # @param component_url [String] SharePoint/OneDrive URL of the .loop file
+          # @param body_text     [String] Optional plain-text preamble shown above the component
+          # @param subject       [String] Optional thread subject line
+          def post_loop_to_channel(team_id:, channel_id:, component_url:, body_text: '', subject: nil, **)
+            attachments = loop_attachment(component_url: component_url, **)[:result]
+            content     = body_text.empty? ? '<p></p>' : "<p>#{body_text}</p>"
+            payload     = { body: { contentType: 'html', content: content }, attachments: attachments }
+            payload[:subject] = subject if subject
+            response = graph_connection(**).post("teams/#{team_id}/channels/#{channel_id}/messages", 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

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

@@ -3,7 +3,7 @@
 module Legion
   module Extensions
     module MicrosoftTeams
-      VERSION = '0.6.36'
+      VERSION = '0.6.40'
     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.36
+  version: 0.6.40
 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
@@ -218,6 +222,7 @@ files:
 - lib/legion/extensions/microsoft_teams/runners/channels.rb
 - lib/legion/extensions/microsoft_teams/runners/chats.rb
 - lib/legion/extensions/microsoft_teams/runners/local_cache.rb
+- lib/legion/extensions/microsoft_teams/runners/loop.rb
 - lib/legion/extensions/microsoft_teams/runners/meetings.rb
 - lib/legion/extensions/microsoft_teams/runners/messages.rb
 - lib/legion/extensions/microsoft_teams/runners/ownership.rb