lex-microsoft_teams 0.6.20 → 0.6.24

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: beeb83d06cdfce621a29d635ac797893d31d9d8403c88a488ee076b278d4a87c
-  data.tar.gz: 759f1937d7693a07e1ad6fa5172583f9d13c58eadce7c12aac3eb42cfb0c75c1
+  metadata.gz: 89010807fc32d72ba6fcefdd2239508ae1d384a14162265d3f97b6098d3114ea
+  data.tar.gz: 9b7909be2dfafd3242fb8407acfa2f0cf0d81365bb4d9606e475e0a40061ffa0
 SHA512:
-  metadata.gz: da442c0b860020406dd65a43b5e6ef9928b0f45e7123709fc2340e81b7288a0a8b94a7e6bb7781bde4c64bc8e071dfcc96b2e24a9b60a0974dc540e3454fd41c
-  data.tar.gz: dcf5a9cf6e7d8a9171131833588b9a41fa5a7a864dc26681b9eee0b31cd6da0e841456d84aefa153dfac51bf16f07350cad3eeed04702f4d85a1376ac062da54
+  metadata.gz: 32d5556151443500353755e7584ca526f778ebff2bdfeb19cd76ef53fc0f660e4ffc4b4ba6468834e06e5841edfc9b3fd3203f36acf03dc2436e40a82d0bf167
+  data.tar.gz: 5f107a3b5ea8cc0afdd662bf170fc06c74b4ba982e966d57b9d876b0e39bc3f422c43b36dc1f3ede9c502acf914f23f83bf7861ddf10f367df09941032832ae6

data/CHANGELOG.md

@@ -1,5 +1,38 @@
 # Changelog
 
+## [Unreleased]
+
+## [0.6.24] - 2026-03-28
+
+### Added
+- `Actors::AbsorbMeeting` — Subscription actor that listens on `lex.microsoft_teams.absorbers.meeting.absorb` and delegates to `Absorbers::Meeting#absorb`
+- `Helpers::GraphClient` — mixin module wrapping `Helpers::Client#graph_connection` with `graph_get`, `graph_post`, `graph_paginate`, and an inline `GraphError` class for responses other than 200, 201, 204, or 404; 401/403 raise with descriptive messages including the Graph error body when available
+
+### Fixed
+- `Absorbers::Meeting#graph_token` — rescue now captures the exception as `=> e` and logs a warning, satisfying the rescue-logging lint rule
+
+## [0.6.23] - 2026-03-27
+
+### Changed
+- `Absorbers::Meeting` — all Graph API runner calls now pass `token: graph_token` so requests carry an `Authorization` header in production. `graph_token` resolves from `Helpers::TokenCache.instance.cached_graph_token` when available, falling back to `nil` (unauthenticated) with a rescued `StandardError` to prevent test-environment boot failures
+- `CLAUDE.md` — version field updated to 0.6.23
+
+## [0.6.22] - 2026-03-27
+
+### Changed
+- `Absorbers::Meeting#handle` now fails fast with `{ success: false, error: 'meeting has no id' }` when the resolved meeting item has no `id` field, preventing subsequent runner calls from building invalid URLs
+- `spec/legion/extensions/microsoft_teams/absorbers/meeting_spec.rb` — added spec covering the blank `meeting_id` guard path
+
+## [0.6.21] - 2026-03-27
+
+### Added
+- `Absorbers::Meeting` — reference implementation of the absorber framework for Teams meetings. Resolves a Teams join URL to a meeting via Graph API, then ingests transcripts (VTT), AI insights, and participant lists into Apollo knowledge store. Two URL patterns registered: `teams.microsoft.com/l/meetup-join/*` and `*.teams.microsoft.com/meet/*`. Guard on `Legion::Extensions::Absorbers` ensures the absorber only loads when the framework base class is available.
+- `spec/spec_helper.rb` — inline stubs for `Legion::Extensions::Absorbers::Base` and `Matchers::Url` so absorber specs run without the full `legionio` gem in the test environment
+
+### Changed
+- `lib/legion/extensions/microsoft_teams/absorbers/meeting.rb` — runner calls now go through `meetings_runner`, `transcripts_runner`, and `ai_insights_runner` instance accessors (`Object.new.extend(Runners::*)`) instead of calling runner modules directly as class methods, which would raise `NoMethodError` at runtime
+- `spec/legion/extensions/microsoft_teams/absorbers/meeting_spec.rb` — specs stub runner instances via `absorber.meetings_runner` / `absorber.transcripts_runner` / `absorber.ai_insights_runner` rather than the module constants; `.patterns` spec no longer relies on `patterns.first` ordering; now asserts both expected pattern values are present in the set
+
 ## [0.6.19] - 2026-03-26
 
 ### Changed

data/CLAUDE.md

@@ -10,7 +10,7 @@ Legion Extension that connects LegionIO to Microsoft Teams via Graph API and Bot
 
 **GitHub**: https://github.com/LegionIO/lex-microsoft_teams
 **License**: MIT
-**Version**: 0.6.18
+**Version**: 0.6.24
 
 ## Architecture
 

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

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module MicrosoftTeams
+      module Absorbers
+        class Meeting < Legion::Extensions::Absorbers::Base
+          pattern :url, 'teams.microsoft.com/l/meetup-join/*'
+          pattern :url, '*.teams.microsoft.com/meet/*'
+          description 'Absorbs Teams meeting transcripts, AI insights, and participants into Apollo'
+
+          def handle(url: nil, content: nil, metadata: {}, context: {}) # rubocop:disable Lint/UnusedMethodArgument
+            report_progress(message: 'resolving meeting from link')
+            meeting = resolve_meeting(url)
+            return { success: false, error: 'could not resolve meeting' } unless meeting
+
+            subject    = meeting['subject'] || meeting[:subject] || 'untitled meeting'
+            meeting_id = meeting['id'] || meeting[:id]
+            return { success: false, error: 'meeting has no id' } if meeting_id.nil? || meeting_id.to_s.empty?
+
+            results = { meeting_id: meeting_id, subject: subject, chunks: 0 }
+
+            ingest_transcript(meeting_id, subject, results)
+            ingest_ai_insights(meeting_id, subject, results)
+            ingest_participants(meeting, subject, results)
+
+            report_progress(message: 'done', percent: 100)
+            results.merge(success: true)
+          rescue StandardError => e
+            log.error("Meeting absorber failed: #{e.message}")
+            { success: false, error: e.message }
+          end
+
+          private
+
+          def meetings_runner
+            @meetings_runner ||= Object.new.extend(Runners::Meetings)
+          end
+
+          def transcripts_runner
+            @transcripts_runner ||= Object.new.extend(Runners::Transcripts)
+          end
+
+          def ai_insights_runner
+            @ai_insights_runner ||= Object.new.extend(Runners::AiInsights)
+          end
+
+          def graph_token
+            return @graph_token if defined?(@graph_token)
+
+            @graph_token = begin
+              Helpers::TokenCache.instance.cached_graph_token if defined?(Helpers::TokenCache)
+            rescue StandardError => e
+              log.warn("graph_token unavailable: #{e.message}")
+              nil
+            end
+          end
+
+          def resolve_meeting(url)
+            report_progress(message: 'looking up meeting by join URL', percent: 5)
+            response = meetings_runner.get_meeting_by_join_url(join_url: url, token: graph_token)
+            return nil unless response.is_a?(Hash)
+
+            body = response[:result]
+            return nil unless body.is_a?(Hash)
+
+            items = body['value'] || body[:value]
+            return nil unless items.is_a?(Array) && !items.empty?
+
+            items.first
+          rescue StandardError => e
+            log.warn("Could not resolve meeting: #{e.message}")
+            nil
+          end
+
+          def ingest_transcript(meeting_id, subject, results)
+            report_progress(message: 'fetching transcripts', percent: 20)
+            transcripts_response = transcripts_runner.list_transcripts(meeting_id: meeting_id, token: graph_token)
+            transcripts_body     = transcripts_response.is_a?(Hash) ? transcripts_response[:result] : nil
+            return unless transcripts_body.is_a?(Hash)
+
+            transcript_items = transcripts_body['value'] || transcripts_body[:value]
+            return unless transcript_items.is_a?(Array) && transcript_items.any?
+
+            transcript_items.each do |t|
+              transcript_id = t['id'] || t[:id]
+              next unless transcript_id
+
+              report_progress(message: "pulling transcript #{transcript_id}", percent: 40)
+              vtt_result = transcripts_runner.get_transcript_content(
+                meeting_id: meeting_id, transcript_id: transcript_id, format: :vtt, token: graph_token
+              )
+              vtt = vtt_result.is_a?(Hash) ? vtt_result[:result] : vtt_result
+              next unless vtt.is_a?(String) && !vtt.empty?
+
+              absorb_to_knowledge(
+                content:      vtt,
+                tags:         ['meeting', 'transcript', subject],
+                source_file:  "teams://meetings/#{meeting_id}/transcripts/#{transcript_id}",
+                heading:      "Transcript: #{subject}",
+                content_type: 'meeting_transcript'
+              )
+              results[:chunks] += 1
+            end
+          rescue StandardError => e
+            log.warn("Transcript ingest failed: #{e.message}")
+          end
+
+          def ingest_ai_insights(meeting_id, subject, results)
+            report_progress(message: 'fetching AI insights', percent: 60)
+            insights = ai_insights_runner.list_meeting_ai_insights(meeting_id: meeting_id, token: graph_token)
+            return unless insights.is_a?(Hash)
+
+            body  = insights[:result] || insights
+            items = body.is_a?(Hash) ? (body['value'] || body[:value]) : nil
+            return unless items.is_a?(Array) && items.any?
+
+            items.each { |item| absorb_insight_item(item, meeting_id, subject, results) }
+          rescue StandardError => e
+            log.warn("AI insights ingest failed: #{e.message}")
+          end
+
+          def absorb_insight_item(item, meeting_id, subject, results)
+            return unless item.is_a?(Hash)
+
+            insight_id   = item['id'] || item[:id]
+            action_items = item['actionItems'] || item[:actionItems] || []
+            return if action_items.empty?
+
+            content = action_items.filter_map { |a| a.is_a?(Hash) ? (a['text'] || a[:text]) : a.to_s }.join("\n")
+            return if content.empty?
+
+            absorb_to_knowledge(
+              content:      content,
+              tags:         ['meeting', 'ai-insight', 'action-item', subject],
+              source_file:  "teams://meetings/#{meeting_id}/insights/#{insight_id}",
+              heading:      "AI Insight: #{subject}",
+              content_type: 'meeting_insight'
+            )
+            results[:chunks] += 1
+          end
+
+          def ingest_participants(meeting, subject, results)
+            report_progress(message: 'recording participants', percent: 80)
+            participants = meeting.dig('participants', 'attendees') || meeting.dig(:participants, :attendees)
+            return unless participants.is_a?(Array) && participants.any?
+
+            names = participants.filter_map do |p|
+              p.dig('identity', 'user', 'displayName') || p.dig(:identity, :user, :displayName)
+            end
+            return if names.empty?
+
+            meeting_id = meeting['id'] || meeting[:id]
+            absorb_raw(
+              content:      "Meeting participants for '#{subject}': #{names.join(', ')}",
+              tags:         ['meeting', 'participants', subject],
+              content_type: 'meeting_participants',
+              metadata:     { meeting_id: meeting_id, participant_count: names.length }
+            )
+            results[:chunks] += 1
+          rescue StandardError => e
+            log.warn("Participant ingest failed: #{e.message}")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module MicrosoftTeams
+      module Actor
+        class AbsorbMeeting < Legion::Extensions::Actors::Subscription
+          def runner_class    = 'Legion::Extensions::MicrosoftTeams::Absorbers::Meeting'
+          def runner_function = 'absorb'
+          def check_subtask?  = false
+          def generate_task?  = false
+
+          def enabled?
+            defined?(Legion::Extensions::Absorbers::Base) &&
+              defined?(Legion::Extensions::MicrosoftTeams::Absorbers::Meeting)
+          rescue StandardError => e
+            log.debug("AbsorbMeeting#enabled?: #{e.message}")
+            false
+          end
+
+          def work(payload)
+            parsed   = parse_payload(payload)
+            absorber = Absorbers::Meeting.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("AbsorbMeeting actor absorb failed: #{result.inspect}")
+                reject!(requeue: false)
+              end
+            else
+              ack!
+            end
+            result
+          rescue StandardError => e
+            log.error("AbsorbMeeting 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("AbsorbMeeting#parse_payload: #{e.message}")
+            {}
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module MicrosoftTeams
+      module Helpers
+        module GraphClient
+          class GraphError < StandardError; end
+
+          def graph_get(path, token:, params: {})
+            connection = graph_connection(token: token)
+            response   = connection.get(path, params)
+            handle_graph_response(response, path)
+          end
+
+          def graph_paginate(path, token:, params: {}, max_pages: 10)
+            results   = []
+            next_link = nil
+            page      = 0
+
+            loop do
+              current_path = next_link || path
+              data         = graph_get(current_path, token: token, params: page.zero? ? params : {})
+              break if data.nil?
+
+              items = data['value'] || data[:value]
+              results.concat(Array(items)) if items
+
+              next_link = data['@odata.nextLink'] || data[:'@odata.nextLink']
+              page     += 1
+              break if next_link.nil? || page >= max_pages
+            end
+
+            results
+          end
+
+          def graph_post(path, token:, body: {})
+            connection = graph_connection(token: token)
+            response   = connection.post(path) do |req|
+              req.body = body
+            end
+            handle_graph_response(response, path)
+          end
+
+          private
+
+          def handle_graph_response(response, path)
+            error_message =
+              if response.body.respond_to?(:dig)
+                response.body.dig('error', 'message') ||
+                  response.body.dig(:error, :message)
+              end
+
+            case response.status
+            when 200, 201
+              response.body
+            when 204, 404
+              nil
+            when 401
+              detail = error_message || 'Access token is missing, expired, or invalid.'
+              raise GraphError, "Graph API 401 Unauthorized on #{path}: #{detail}"
+            when 403
+              detail = error_message || 'Caller does not have sufficient permissions to perform this action.'
+              raise GraphError, "Graph API 403 Forbidden on #{path}: #{detail}"
+            else
+              base_message = "Graph API #{response.status} on #{path}"
+              base_message = "#{base_message}: #{error_message}" if error_message
+              raise GraphError, base_message
+            end
+          end
+        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.20'
+      VERSION = '0.6.24'
     end
   end
 end

data/lib/legion/extensions/microsoft_teams.rb

@@ -33,6 +33,7 @@ require 'legion/extensions/microsoft_teams/helpers/callback_server'
 require 'legion/extensions/microsoft_teams/helpers/browser_auth'
 require 'legion/extensions/microsoft_teams/helpers/permission_guard'
 require 'legion/extensions/microsoft_teams/helpers/transform_definitions'
+require 'legion/extensions/microsoft_teams/helpers/graph_client'
 
 # Transport
 if defined?(Legion::Transport)
@@ -43,6 +44,12 @@ end
 
 require 'legion/extensions/microsoft_teams/client'
 
+if defined?(Legion::Extensions) &&
+   Legion::Extensions.const_defined?(:Absorbers, false) &&
+   Legion::Extensions::Absorbers.const_defined?(:Base, false)
+  require_relative 'microsoft_teams/absorbers/meeting'
+end
+
 module Legion
   module Extensions
     module MicrosoftTeams

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-microsoft_teams
 version: !ruby/object:Gem::Version
-  version: 0.6.20
+  version: 0.6.24
 platform: ruby
 authors:
 - Esity
@@ -175,6 +175,8 @@ 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/meeting.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
 - lib/legion/extensions/microsoft_teams/actors/cache_bulk_ingest.rb
@@ -193,6 +195,7 @@ files:
 - lib/legion/extensions/microsoft_teams/helpers/browser_auth.rb
 - lib/legion/extensions/microsoft_teams/helpers/callback_server.rb
 - lib/legion/extensions/microsoft_teams/helpers/client.rb
+- lib/legion/extensions/microsoft_teams/helpers/graph_client.rb
 - lib/legion/extensions/microsoft_teams/helpers/high_water_mark.rb
 - lib/legion/extensions/microsoft_teams/helpers/permission_guard.rb
 - lib/legion/extensions/microsoft_teams/helpers/prompt_resolver.rb