lex-microsoft_teams 0.6.16 → 0.6.17

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7ad20d81a8d2c2a597d2415f896f8ae4c8209efde74efd99fd0c1b630cc2ce60
-  data.tar.gz: 44d7b8e2d0831df8116a44379096f9264d6d27302d8787fdc97a9652762f5c3b
+  metadata.gz: 832e104a03125c669c37edf62529da10ffb5bd5b4267de12ba91c764a4e168ae
+  data.tar.gz: f6c47a1c6af1903e9bec4aec82363f4d01a439d353236144213f3c677923c14f
 SHA512:
-  metadata.gz: e6d66af6d00faed231e1d889e60f906f22f03a79ff9ebced10745fd41cb0a260929f1fb25222e39a6a6c0705414799e768a36ab1f163cdf7c67980654c3ccbb7
-  data.tar.gz: 54fe1f02a29d2edb885bec85f56c94173b7857815d01532299fb05e985535eace1237a9322bc54a0752efdb68213e2e7701d27fecbd765f6bb250b4ae4361216
+  metadata.gz: 16bac537f53a87e92a2d37ee697eb8759739e67530e4262c18378f7af532afe5c192c3843d4bfdaafc807636b9fafea83381d36089bbaa21888ed5decf734907
+  data.tar.gz: daf6dda8b96102a644d002b7890f2faf3b343f9600bd9c8e00fa76a5db1b0ad380ab9b37addb7480a12b71f0bbbd1ac9bc00247d6d1b75dd451b19953062f93b

data/CHANGELOG.md

@@ -5,6 +5,17 @@
 ### Changed
 - add caller identity to llm_chat calls in bot and profile_ingest runners for pipeline attribution
 
+## [0.6.17] - 2026-03-24
+
+### Added
+- `Helpers::TraceRetriever` module: retrieves memory traces from the shared store at query time and formats them as LLM context (sender, teams, and chat-scoped domains; 2000-token budget; strength-ranked deduplication)
+- `Bot#retrieve_trace_context` private method wires TraceRetriever into the handle_message flow
+- `Bot#handle_message` now retrieves trace context before generating a response and passes it through to `generate_response` and `llm_respond`
+- `SessionManager#get_or_create` seeds new sessions with profile traces for the owner via `trace_seed_for`
+- `PromptResolver#resolve_prompt` accepts optional `trace_context:` keyword and appends it after preference instructions
+- Comprehensive specs for TraceRetriever (token budget, rank/dedup, age labels, graceful degradation)
+- Bot specs updated to verify trace context retrieval and pass-through, and nil/graceful-degradation paths
+
 ## [0.6.15] - 2026-03-23
 
 ### Added

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

@@ -5,7 +5,7 @@ module Legion
     module MicrosoftTeams
       module Helpers
         module PromptResolver
-          def resolve_prompt(mode:, conversation_id:, owner_id: nil)
+          def resolve_prompt(mode:, conversation_id:, owner_id: nil, trace_context: nil)
             settings = teams_settings
             base = settings.dig(:bot, :system_prompt) || ''
 
@@ -18,6 +18,8 @@ module Legion
             pref_instructions = preference_instructions_for(owner_id: owner_id)
             prompt = "#{prompt}\n\n#{pref_instructions}" if pref_instructions
 
+            prompt = "#{prompt}\n\n#{trace_context}" if trace_context && !trace_context.empty?
+
             prompt
           end
 

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

@@ -35,6 +35,9 @@ module Legion
               llm_config:    resolve_llm_config(mode: mode, conversation_id: conversation_id, owner_id: owner_id)
             }
 
+            seed = trace_seed_for(owner_id: owner_id)
+            session[:trace_seed] = seed if seed
+
             @sessions[conversation_id] = session
           end
 
@@ -134,6 +137,22 @@ module Legion
             @memory_runner ||= Object.new.extend(Legion::Extensions::Agentic::Memory::Trace::Runners::Traces)
           end
 
+          def trace_seed_for(owner_id:)
+            return nil unless defined?(Legion::Extensions::Agentic::Memory::Trace) &&
+                              Legion::Extensions::Agentic::Memory::Trace.respond_to?(:shared_store)
+
+            store = Legion::Extensions::Agentic::Memory::Trace.shared_store
+            return nil unless store
+
+            profile_traces = store.retrieve_by_domain("sender:#{owner_id}", min_strength: 0.3, limit: 5)
+            return nil if profile_traces.empty?
+
+            profile_traces.map { |t| { type: t[:trace_type], content: t[:content_payload].to_s[0, 200] } }
+          rescue StandardError => e
+            log.debug("trace_seed_for failed: #{e.message}") if defined?(log) && log.respond_to?(:debug)
+            nil
+          end
+
           def settings_val(key, default)
             if defined?(Legion::Settings) && Legion::Settings.dig(:microsoft_teams, :bot, :session, key)
               Legion::Settings[:microsoft_teams][:bot][:session][key]

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

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module MicrosoftTeams
+      module Helpers
+        module TraceRetriever
+          MAX_TRACE_TOKENS = 2000
+          MAX_TRACES = 20
+
+          def retrieve_context(message:, owner_id:, chat_id: nil, channel_id: nil) # rubocop:disable Lint/UnusedMethodArgument
+            return nil unless memory_trace_available?
+
+            traces = []
+            traces.concat(retrieve_sender_traces(owner_id: owner_id))
+            traces.concat(retrieve_teams_traces)
+            traces.concat(retrieve_chat_traces(chat_id: chat_id)) if chat_id
+
+            ranked = rank_traces(traces: traces, query: message)
+            format_trace_context(traces: ranked.first(MAX_TRACES))
+          rescue StandardError => e
+            log_trace_error('retrieve_context', e)
+            nil
+          end
+
+          private
+
+          def retrieve_sender_traces(owner_id:)
+            return [] unless owner_id
+
+            store = shared_trace_store
+            return [] unless store
+
+            store.retrieve_by_domain("sender:#{owner_id}", min_strength: 0.1, limit: 10)
+          rescue StandardError => e
+            log_trace_error('retrieve_sender_traces', e)
+            []
+          end
+
+          def retrieve_teams_traces
+            store = shared_trace_store
+            return [] unless store
+
+            store.retrieve_by_domain('teams', min_strength: 0.3, limit: 10)
+          rescue StandardError => e
+            log_trace_error('retrieve_teams_traces', e)
+            []
+          end
+
+          def retrieve_chat_traces(chat_id:)
+            store = shared_trace_store
+            return [] unless store
+
+            store.retrieve_by_domain("chat:#{chat_id}", min_strength: 0.1, limit: 5)
+          rescue StandardError => e
+            log_trace_error('retrieve_chat_traces', e)
+            []
+          end
+
+          def rank_traces(traces:, query:) # rubocop:disable Lint/UnusedMethodArgument
+            seen = Set.new
+            unique = traces.select { |t| seen.add?(t[:trace_id]) }
+
+            unique.sort_by { |t| [-(t[:strength] || 0.0), -t[:last_reinforced].to_f] }
+          end
+
+          def format_trace_context(traces:)
+            return nil if traces.empty?
+
+            lines = ['## Organizational Context (from memory)']
+            token_estimate = 0
+
+            traces.each do |trace|
+              line = format_single_trace(trace)
+              next unless line
+
+              line_tokens = line.length / 4
+              break if token_estimate + line_tokens > MAX_TRACE_TOKENS
+
+              lines << line
+              token_estimate += line_tokens
+            end
+
+            return nil if lines.size <= 1
+
+            lines.join("\n")
+          end
+
+          def format_single_trace(trace)
+            type = trace[:trace_type] || :unknown
+            content = trace[:content_payload].to_s
+            content = "#{content[0, 200]}..." if content.length > 200
+
+            tags = (trace[:domain_tags] || []).join(', ')
+            age = trace_age_label(trace[:created_at] || trace[:last_reinforced])
+
+            "- [#{type}] #{content} (#{age}, tags: #{tags})"
+          rescue StandardError
+            nil
+          end
+
+          def trace_age_label(timestamp)
+            return 'unknown age' unless timestamp
+
+            seconds = Time.now - (timestamp.is_a?(Time) ? timestamp : Time.parse(timestamp.to_s))
+            case seconds
+            when 0..3600 then 'just now'
+            when 3600..86_400 then "#{(seconds / 3600).to_i}h ago"
+            when 86_400..604_800 then "#{(seconds / 86_400).to_i}d ago"
+            else "#{(seconds / 604_800).to_i}w ago"
+            end
+          rescue StandardError
+            'unknown age'
+          end
+
+          def memory_trace_available?
+            defined?(Legion::Extensions::Agentic::Memory::Trace)
+          end
+
+          def shared_trace_store
+            return nil unless defined?(Legion::Extensions::Agentic::Memory::Trace) &&
+                              Legion::Extensions::Agentic::Memory::Trace.respond_to?(:shared_store)
+
+            Legion::Extensions::Agentic::Memory::Trace.shared_store
+          end
+
+          def log_trace_error(method, error)
+            return unless defined?(log)
+
+            log.debug("TraceRetriever##{method} failed: #{error.message}")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -4,6 +4,7 @@ require 'json'
 require 'legion/extensions/microsoft_teams/helpers/client'
 require_relative '../helpers/session_manager'
 require_relative '../helpers/subscription_registry'
+require_relative '../helpers/trace_retriever'
 
 module Legion
   module Extensions
@@ -12,6 +13,7 @@ module Legion
         module Bot
           include Legion::Extensions::MicrosoftTeams::Helpers::Client
           include Legion::Extensions::MicrosoftTeams::Helpers::PromptResolver
+          include Legion::Extensions::MicrosoftTeams::Helpers::TraceRetriever
 
           def send_activity(service_url:, conversation_id:, activity:, **)
             conn = bot_connection(service_url: service_url, **)
@@ -97,7 +99,8 @@ module Legion
             )
             session_manager.add_message(conversation_id: conversation_id, role: :user, content: text)
 
-            response_text = generate_response(text: text, session: session)
+            trace_context = retrieve_trace_context(message: text, owner_id: owner_id, chat_id: chat_id)
+            response_text = generate_response(text: text, session: session, trace_context: trace_context)
 
             reply_result = send_reply(
               chat_id:         chat_id,
@@ -166,17 +169,20 @@ module Legion
 
           private
 
-          def generate_response(text:, session:)
-            return llm_respond(text: text, session: session) if llm_available?
+          def generate_response(text:, session:, trace_context: nil)
+            return llm_respond(text: text, session: session, trace_context: trace_context) if llm_available?
 
             "Echo: #{text}"
           end
 
-          def llm_respond(text:, session:)
+          def llm_respond(text:, session:, trace_context: nil)
             config = session[:llm_config] || {}
+            instructions = session[:system_prompt]
+            instructions = "#{instructions}\n\n#{trace_context}" if trace_context && !trace_context.empty?
+
             response = llm_chat(
               text,
-              instructions: session[:system_prompt],
+              instructions: instructions,
               model:        config[:model],
               intent:       config[:intent],
               caller:       { id: session[:owner_id], extension: 'lex-microsoft_teams', mode: :bot_response }
@@ -187,6 +193,15 @@ module Legion
             'I encountered an error processing your message. Please try again.'
           end
 
+          def retrieve_trace_context(message:, owner_id:, chat_id:)
+            return nil unless respond_to?(:retrieve_context, true)
+
+            retrieve_context(message: message, owner_id: owner_id, chat_id: chat_id)
+          rescue StandardError => e
+            log.debug("retrieve_trace_context failed: #{e.message}") if defined?(log)
+            nil
+          end
+
           def llm_available?
             defined?(Legion::LLM) && Legion::LLM.respond_to?(:chat)
           end

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

@@ -3,7 +3,7 @@
 module Legion
   module Extensions
     module MicrosoftTeams
-      VERSION = '0.6.16'
+      VERSION = '0.6.17'
     end
   end
 end

data/lib/legion/extensions/microsoft_teams.rb

@@ -25,6 +25,7 @@ require 'legion/extensions/microsoft_teams/runners/api_ingest'
 # Helpers (bot)
 require 'legion/extensions/microsoft_teams/helpers/high_water_mark'
 require 'legion/extensions/microsoft_teams/helpers/prompt_resolver'
+require 'legion/extensions/microsoft_teams/helpers/trace_retriever'
 require 'legion/extensions/microsoft_teams/helpers/session_manager'
 require 'legion/extensions/microsoft_teams/helpers/subscription_registry'
 require 'legion/extensions/microsoft_teams/helpers/token_cache'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-microsoft_teams
 version: !ruby/object:Gem::Version
-  version: 0.6.16
+  version: 0.6.17
 platform: ruby
 authors:
 - Esity
@@ -197,6 +197,7 @@ files:
 - lib/legion/extensions/microsoft_teams/helpers/session_manager.rb
 - lib/legion/extensions/microsoft_teams/helpers/subscription_registry.rb
 - lib/legion/extensions/microsoft_teams/helpers/token_cache.rb
+- lib/legion/extensions/microsoft_teams/helpers/trace_retriever.rb
 - lib/legion/extensions/microsoft_teams/helpers/transform_definitions.rb
 - lib/legion/extensions/microsoft_teams/hooks/auth.rb
 - lib/legion/extensions/microsoft_teams/local_cache/extractor.rb