lex-microsoft_teams 0.6.14 → 0.6.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7e4252f4382060712bb112a7d7beaf55b10947fe6200185a3fb6ee413e4f3927
-  data.tar.gz: af5fb381e122efd02feab899a484242c71f5b67fb620717fad6dcb12c372e2cd
+  metadata.gz: 1f1d44ab9629e5fae32a00f28afb74942d9872083de6e378e6585eeb7ae091ba
+  data.tar.gz: 5994c5df760cbe750b1dbb53dfc7de3f04812d173efd29cad18d5d49890c85e3
 SHA512:
-  metadata.gz: 22a8726642d3a8209c09c4fc797812825cd21ae7dcc8818438333a62291fa9a3a08356125e5003a426e8098ba56ad8033e77a1fd0bb4a162bd6c989bd20b127d
-  data.tar.gz: 89f55fcbe2210cc4f55a77d4ee04407fe0a3ba437cb1ad14e4699468f0dfbdcf1481ae72d01f230305c0ded9c9e2b1a1558360502ae43a27428d9f5d72634377
+  metadata.gz: 7548451323db291361400838619ba453d2b1eac29ac5291ab3688f61b604d1600aca5841446f60816fc10639905b03a1edcde82cbff80b66848a8ed6fc90c48f
+  data.tar.gz: 5a0c144c9ee151dd7a68d621377ea591fbbb0e83ef03b208e877f979a69be1681e6af5bfa32533f560cdfd8626cadf4193f74fcb1af5b4771f0a11d8b298b817

data/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## [0.6.15] - 2026-03-23
+
+### Added
+- Apollo knowledge graph integration: ingest conversation observations and extract entities from Teams messages
+- `publish_to_apollo` feeds per-person message summaries into Apollo's knowledge store as observations
+- `extract_and_ingest_entities` uses Apollo EntityExtractor to identify people, services, repos, and concepts
+- Soft guards: Apollo integration is a no-op when lex-apollo or legion-data are not loaded
+
 ## [0.6.14] - 2026-03-23
 
 ### Added

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

@@ -39,6 +39,7 @@ module Legion
             skipped = 0
             people_ingested = 0
             thread_groups = Hash.new { |h, k| h[k] = [] }
+            person_texts = Hash.new { |h, k| h[k] = [] }
 
             people.each do |person|
               chat = match_chat_to_person(chats: chats, person: person, conn: conn)
@@ -73,6 +74,7 @@ module Legion
                   msg_stored += 1
                   existing_hashes << content_hash
                   thread_groups[chat['id']] << trace_result[:trace_id]
+                  person_texts[person['displayName']] << text
                 else
                   skipped += 1
                 end
@@ -88,9 +90,11 @@ module Legion
 
             coactivate_thread_traces(thread_groups)
             flush_trace_store if stored.positive?
+            apollo_results = publish_to_apollo(person_texts) if stored.positive?
 
             { result: { stored: stored, skipped: skipped, people_ingested: people_ingested,
-                        people_found: people.length, chats_found: chats.length } }
+                        people_found: people.length, chats_found: chats.length,
+                        apollo: apollo_results } }
           rescue StandardError => e
             log_msg = "ApiIngest failed: #{e.class} — #{e.message}"
             log.error(log_msg)
@@ -297,6 +301,78 @@ module Legion
             log.debug("ApiIngest: coactivation skipped: #{e.message}")
           end
 
+          def publish_to_apollo(person_texts)
+            return { skipped: true, reason: :apollo_unavailable } unless apollo_available?
+
+            ingested = 0
+            entities_found = 0
+            knowledge_runner = apollo_knowledge_runner
+
+            person_texts.each do |person_name, texts|
+              combined = texts.join("\n\n")
+              next if combined.length < 20
+
+              result = knowledge_runner.handle_ingest(
+                content:         "Conversation observations from #{person_name}: #{combined[0, 2000]}",
+                content_type:    :observation,
+                tags:            ['teams', 'graph_api', "peer:#{person_name}"],
+                source_agent:    'teams-api-ingest',
+                source_provider: 'microsoft',
+                source_channel:  'teams_graph_api',
+                context:         { person: person_name, message_count: texts.length }
+              )
+              ingested += 1 if result[:success]
+
+              entity_result = extract_and_ingest_entities(combined, person_name, knowledge_runner)
+              entities_found += entity_result[:count] if entity_result[:success]
+            end
+
+            { ingested: ingested, entities_found: entities_found }
+          rescue StandardError => e
+            log.warn("ApiIngest: publish_to_apollo failed: #{e.message}")
+            { skipped: true, reason: :error, error: e.message }
+          end
+
+          def extract_and_ingest_entities(text, person_name, knowledge_runner)
+            return { success: false, count: 0 } unless entity_extractor_available?
+
+            extractor = Object.new.extend(Legion::Extensions::Apollo::Runners::EntityExtractor)
+            result = extractor.extract_entities(text: text[0, 4000])
+            return { success: false, count: 0 } unless result[:success] && result[:entities]&.any?
+
+            result[:entities].each do |entity|
+              knowledge_runner.handle_ingest(
+                content:         "#{entity[:type]}: #{entity[:name]}",
+                content_type:    entity[:type] == 'person' ? :association : :concept,
+                tags:            ['teams', 'entity', "entity_type:#{entity[:type]}", "peer:#{person_name}"],
+                source_agent:    'teams-entity-extractor',
+                source_provider: 'microsoft',
+                source_channel:  'teams_graph_api',
+                context:         { entity_name: entity[:name], entity_type: entity[:type],
+                                   confidence: entity[:confidence], extracted_from: person_name }
+              )
+            end
+
+            { success: true, count: result[:entities].length }
+          rescue StandardError => e
+            log.debug("ApiIngest: entity extraction failed for #{person_name}: #{e.message}")
+            { success: false, count: 0 }
+          end
+
+          def apollo_available?
+            defined?(Legion::Extensions::Apollo::Runners::Knowledge) &&
+              defined?(Legion::Data::Model::ApolloEntry)
+          end
+
+          def entity_extractor_available?
+            defined?(Legion::Extensions::Apollo::Runners::EntityExtractor) &&
+              defined?(Legion::LLM) && Legion::LLM.respond_to?(:started?) && Legion::LLM.started?
+          end
+
+          def apollo_knowledge_runner
+            @apollo_knowledge_runner ||= Object.new.extend(Legion::Extensions::Apollo::Runners::Knowledge)
+          end
+
           def error_result(message)
             { result: { stored: 0, skipped: 0, error: message } }
           end

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

@@ -3,7 +3,7 @@
 module Legion
   module Extensions
     module MicrosoftTeams
-      VERSION = '0.6.14'
+      VERSION = '0.6.15'
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-microsoft_teams
 version: !ruby/object:Gem::Version
-  version: 0.6.14
+  version: 0.6.15
 platform: ruby
 authors:
 - Esity