lex-mesh 0.3.4 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4153ff1a3ae99b32c170e6d190817a51e27318ea532505186ec16dcc1ae45ae6
-  data.tar.gz: 467dcb6344f58e2019d35e21d6ede60ea335d63f3aacf82bc4aed9dd05a14134
+  metadata.gz: fbc0df66608354b5104c675cc838ceede54f6efde1e7877a38d1dda1f53a96bd
+  data.tar.gz: efc6aaffe3bb7bbc45df398c0b303dcc8945a513d1c949c545e0707ebfdfd368
 SHA512:
-  metadata.gz: cb648562211012a2569cf6a345397a7283d6fff71de672fda94452e631dfd2d6943f868a1ac39a62c2c9273d46dfc727ac85a3595a27e1eaae071bd4fff9b771
-  data.tar.gz: 98b4fce6a1c579507f4201243b739d46a10e7a649fb7939214c27c29af21abaf1f06d12b24ee63e05d3f0143106b9377a7ce51c864916adea85ec80dbd04956a
+  metadata.gz: a1da77aeb0c9c9f9eea9a9b506457e55c19a5cb68605a8ed2069c37bf35ecc6337d7ff28b781dd50afa96805d08b9288d261d1072fa7dd4078c8aca2d0069fc3
+  data.tar.gz: 1700abac8d24b5b1362d4112128fe02fbcc991bb5e4779ecf427196fa8f0fb919419b20d85778d07d7d11621023c1c8e7523b125958ca3fea5ba5c614dabbbbe

data/lib/legion/extensions/mesh/helpers/preference_profile.rb

@@ -121,6 +121,84 @@ module Legion
             lines.join(' ')
           end
 
+          MESH_CACHE_TTL = 3600 # 1 hour default
+
+          def store_mesh_profile(agent_id:, profile:, source_agent_id:)
+            @mesh_cache ||= {}
+            @mesh_cache[agent_id.to_s] = {
+              profile:         profile,
+              source_agent_id: source_agent_id,
+              origin:          :mesh_transfer,
+              cached_at:       Time.now
+            }
+
+            if memory_available?
+              store_preference(
+                owner_id: agent_id,
+                domain:   'mesh_profile',
+                value:    profile.to_s,
+                source:   'mesh_transfer'
+              )
+            end
+
+            { stored: true, agent_id: agent_id, origin: :mesh_transfer }
+          rescue StandardError => e
+            { stored: false, error: e.message }
+          end
+
+          def cached_mesh_profile(agent_id:, ttl: MESH_CACHE_TTL)
+            @mesh_cache ||= {}
+            entry = @mesh_cache[agent_id.to_s]
+            return nil unless entry
+
+            if Time.now - entry[:cached_at] > ttl
+              @mesh_cache.delete(agent_id.to_s)
+              return nil
+            end
+
+            entry[:profile]
+          rescue StandardError
+            nil
+          end
+
+          def clear_mesh_cache(agent_id: nil)
+            @mesh_cache ||= {}
+            if agent_id
+              @mesh_cache.delete(agent_id.to_s)
+            else
+              @mesh_cache.clear
+            end
+          end
+
+          def for_agent(agent_id:, ttl: MESH_CACHE_TTL)
+            cached = cached_mesh_profile(agent_id: agent_id, ttl: ttl)
+            if cached
+              return {
+                source:        :mesh_cache,
+                profile:       cached,
+                agent_id:      agent_id,
+                compatibility: compute_compatibility(cached)
+              }
+            end
+
+            profile = resolve(owner_id: agent_id)
+
+            {
+              source:        :local,
+              profile:       profile,
+              agent_id:      agent_id,
+              compatibility: compute_compatibility(profile)
+            }
+          rescue StandardError => e
+            {
+              source:        :local,
+              profile:       DEFAULTS.dup,
+              agent_id:      agent_id,
+              compatibility: nil,
+              error:         e.message
+            }
+          end
+
           def memory_available?
             defined?(Legion::Extensions::Memory::Runners::Traces)
           end
@@ -151,6 +229,23 @@ module Legion
           rescue StandardError
             nil
           end
+
+          def compute_compatibility(profile)
+            return nil unless profile.is_a?(Hash) && profile[:personality]
+            return nil unless personality_available?
+
+            personality_runner = Object.new.extend(
+              Legion::Extensions::Agentic::Self::Personality::Runners::Personality
+            )
+            result = personality_runner.personality_compatibility(other_profile: profile[:personality])
+            { score: result[:compatibility], interpretation: result[:interpretation] }
+          rescue StandardError
+            nil
+          end
+
+          def personality_available?
+            defined?(Legion::Extensions::Agentic::Self::Personality::Runners::Personality)
+          end
         end
       end
     end

data/lib/legion/extensions/mesh/runners/preferences.rb

@@ -30,7 +30,12 @@ module Legion
             { success: true, source: :local_default, profile: default_profile, error: e.message }
           end
 
-          def handle_preference_query(**)
+          def handle_preference_query(requesting_agent_id: nil, **)
+            if trust_available? && requesting_agent_id
+              trust_result = check_requester_trust(requesting_agent_id)
+              return { success: false, reason: :insufficient_trust, responding_agent_id: local_agent_id } if trust_result == :denied
+            end
+
             owner_id = local_agent_id
             profile = Helpers::PreferenceProfile.resolve(owner_id: owner_id)
 
@@ -39,7 +44,15 @@ module Legion
             { success: false, error: e.message }
           end
 
-          def handle_preference_response(correlation_id:, profile:, **)
+          def handle_preference_response(correlation_id:, profile:, responding_agent_id: nil, **)
+            if responding_agent_id && profile.is_a?(Hash)
+              Helpers::PreferenceProfile.store_mesh_profile(
+                agent_id:        responding_agent_id,
+                profile:         profile,
+                source_agent_id: responding_agent_id
+              )
+            end
+
             resolved = pending_requests.resolve(correlation_id: correlation_id, result: profile)
             { resolved: resolved }
           end
@@ -57,8 +70,9 @@ module Legion
               profile
             when 'preference_response'
               handle_preference_response(
-                correlation_id: msg[:correlation_id],
-                profile:        msg[:profile] || {}
+                correlation_id:      msg[:correlation_id],
+                profile:             msg[:profile] || {},
+                responding_agent_id: msg[:responding_agent_id]
               )
             else
               { success: false, error: "unknown preference message type: #{type}" }
@@ -110,11 +124,28 @@ module Legion
           end
 
           def default_preference_callback(target_agent_id:)
-            lambda do |profile|
-              log_debug("[mesh] received preferences for #{target_agent_id}: #{profile.keys.join(', ')}")
+            lambda do |_profile|
+              log_debug("[mesh] received and cached preferences for #{target_agent_id}")
             end
           end
 
+          def trust_available?
+            defined?(Legion::Extensions::Agentic::Social::Trust::Runners::Trust)
+          end
+
+          def check_requester_trust(agent_id)
+            trust_mod = Legion::Extensions::Agentic::Social::Trust::Runners::Trust
+            evaluator = Object.new.extend(trust_mod)
+            result = evaluator.get_trust(agent_id: agent_id, domain: :general)
+
+            return :allowed unless result[:found]
+
+            composite = result.dig(:trust, :composite) || 0.0
+            composite >= Helpers::Topology::TRUST_CONSIDER_THRESHOLD ? :allowed : :denied
+          rescue StandardError
+            :allowed
+          end
+
           def log_debug(msg)
             log.debug(msg)
           end

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

@@ -3,7 +3,7 @@
 module Legion
   module Extensions
     module Mesh
-      VERSION = '0.3.4'
+      VERSION = '0.4.0'
     end
   end
 end

data/spec/legion/extensions/mesh/helpers/preference_profile_spec.rb

@@ -105,6 +105,88 @@ RSpec.describe Legion::Extensions::Mesh::Helpers::PreferenceProfile do
     end
   end
 
+  describe '.store_mesh_profile' do
+    it 'stores a profile with mesh_transfer origin' do
+      result = described_class.store_mesh_profile(
+        agent_id:        'agent-42',
+        profile:         { verbosity: :concise, tone: :casual },
+        source_agent_id: 'agent-42'
+      )
+      expect(result[:stored]).to be true
+      expect(result[:origin]).to eq(:mesh_transfer)
+    end
+  end
+
+  describe '.cached_mesh_profile' do
+    it 'returns nil when no cached profile exists' do
+      result = described_class.cached_mesh_profile(agent_id: 'agent-unknown')
+      expect(result).to be_nil
+    end
+
+    it 'returns cached profile after store' do
+      described_class.store_mesh_profile(
+        agent_id:        'agent-42',
+        profile:         { verbosity: :concise, tone: :casual },
+        source_agent_id: 'agent-42'
+      )
+      result = described_class.cached_mesh_profile(agent_id: 'agent-42')
+      expect(result).to be_a(Hash)
+      expect(result[:verbosity]).to eq(:concise)
+    end
+
+    it 'returns nil for expired cache entries' do
+      described_class.store_mesh_profile(
+        agent_id:        'agent-42',
+        profile:         { verbosity: :concise },
+        source_agent_id: 'agent-42'
+      )
+      # Expire the entry by manipulating the cache timestamp
+      cache = described_class.instance_variable_get(:@mesh_cache)
+      cache['agent-42'][:cached_at] = Time.now - 7200 if cache&.dig('agent-42')
+      result = described_class.cached_mesh_profile(agent_id: 'agent-42', ttl: 3600)
+      expect(result).to be_nil
+    end
+  end
+
+  describe '.for_agent' do
+    before { described_class.clear_mesh_cache }
+
+    it 'returns local profile when no mesh cache exists' do
+      result = described_class.for_agent(agent_id: 'agent-99')
+      expect(result[:source]).to eq(:local)
+      expect(result[:profile]).to be_a(Hash)
+      expect(result[:profile][:verbosity]).to eq(:normal)
+    end
+
+    it 'returns cached mesh profile when available' do
+      described_class.store_mesh_profile(
+        agent_id:        'agent-42',
+        profile:         { verbosity: :concise, tone: :formal },
+        source_agent_id: 'agent-42'
+      )
+      result = described_class.for_agent(agent_id: 'agent-42')
+      expect(result[:source]).to eq(:mesh_cache)
+      expect(result[:profile][:verbosity]).to eq(:concise)
+    end
+
+    it 'falls back to local when mesh cache is expired' do
+      described_class.store_mesh_profile(
+        agent_id:        'agent-42',
+        profile:         { verbosity: :concise },
+        source_agent_id: 'agent-42'
+      )
+      cache = described_class.instance_variable_get(:@mesh_cache)
+      cache['agent-42'][:cached_at] = Time.now - 7200
+      result = described_class.for_agent(agent_id: 'agent-42')
+      expect(result[:source]).to eq(:local)
+    end
+
+    it 'includes compatibility when available' do
+      result = described_class.for_agent(agent_id: 'agent-99')
+      expect(result).to have_key(:compatibility)
+    end
+  end
+
   describe '.preference_instructions' do
     it 'generates natural language prompt instructions from profile' do
       profile = {

data/spec/legion/extensions/mesh/runners/preferences_spec.rb

@@ -65,6 +65,41 @@ RSpec.describe Legion::Extensions::Mesh::Runners::Preferences do
       result = runner.handle_preference_query(requesting_agent_id: 'agent-1')
       expect(result[:profile]).to have_key(:verbosity)
     end
+
+    context 'with trust module available' do
+      let(:trust_runner) do
+        Module.new do
+          def get_trust(agent_id:, domain: :general, **)
+            case agent_id
+            when 'trusted-agent' then { found: true, trust: { composite: 0.8 } }
+            when 'untrusted-agent' then { found: true, trust: { composite: 0.1 } }
+            else { found: false, agent_id: agent_id, domain: domain }
+            end
+          end
+        end
+      end
+
+      before do
+        stub_const('Legion::Extensions::Agentic::Social::Trust::Runners::Trust', trust_runner)
+      end
+
+      it 'returns profile for trusted agents' do
+        result = runner.handle_preference_query(requesting_agent_id: 'trusted-agent')
+        expect(result[:success]).to be true
+        expect(result[:profile]).to be_a(Hash)
+      end
+
+      it 'refuses preferences for untrusted agents' do
+        result = runner.handle_preference_query(requesting_agent_id: 'untrusted-agent')
+        expect(result[:success]).to be false
+        expect(result[:reason]).to eq(:insufficient_trust)
+      end
+
+      it 'returns profile for unknown agents (trust not found defaults to open)' do
+        result = runner.handle_preference_query(requesting_agent_id: 'unknown-agent')
+        expect(result[:success]).to be true
+      end
+    end
   end
 
   describe '#handle_preference_response' do
@@ -125,6 +160,22 @@ RSpec.describe Legion::Extensions::Mesh::Runners::Preferences do
         )
         expect(result[:resolved]).to be false
       end
+
+      it 'passes responding_agent_id for mesh caching' do
+        pending_req = runner.send(:pending_requests)
+        pending_req.register(correlation_id: 'corr-dispatch', callback: ->(_p) {})
+        runner.dispatch_preference_message(
+          type:                'preference_response',
+          correlation_id:      'corr-dispatch',
+          profile:             { verbosity: :terse },
+          responding_agent_id: 'agent-77'
+        )
+        cached = Legion::Extensions::Mesh::Helpers::PreferenceProfile.cached_mesh_profile(
+          agent_id: 'agent-77'
+        )
+        expect(cached).to be_a(Hash)
+        expect(cached[:verbosity]).to eq(:terse)
+      end
     end
 
     context 'with unknown type' do
@@ -143,6 +194,73 @@ RSpec.describe Legion::Extensions::Mesh::Runners::Preferences do
     end
   end
 
+  describe '#handle_preference_response with mesh caching' do
+    it 'caches the received profile' do
+      pending_req = runner.send(:pending_requests)
+      pending_req.register(
+        correlation_id: 'corr-cache',
+        callback:       ->(profile) {}
+      )
+      runner.handle_preference_response(
+        correlation_id:      'corr-cache',
+        profile:             { verbosity: :concise, tone: :casual },
+        responding_agent_id: 'agent-42'
+      )
+      cached = Legion::Extensions::Mesh::Helpers::PreferenceProfile.cached_mesh_profile(
+        agent_id: 'agent-42'
+      )
+      expect(cached).to be_a(Hash)
+      expect(cached[:verbosity]).to eq(:concise)
+    end
+  end
+
+  describe 'personality compatibility' do
+    context 'without personality module' do
+      it 'returns nil compatibility in for_agent' do
+        result = Legion::Extensions::Mesh::Helpers::PreferenceProfile.for_agent(agent_id: 'agent-99')
+        expect(result[:compatibility]).to be_nil
+      end
+    end
+
+    context 'with personality module available' do
+      let(:personality_runner) do
+        Module.new do
+          def personality_compatibility(**)
+            { compatibility: 0.82, interpretation: :compatible }
+          end
+
+          private
+
+          def personality_store
+            @personality_store ||= Struct.new(:model).new(nil)
+          end
+        end
+      end
+
+      before do
+        stub_const(
+          'Legion::Extensions::Agentic::Self::Personality::Runners::Personality',
+          personality_runner
+        )
+      end
+
+      it 'returns compatibility score when personality data exists' do
+        Legion::Extensions::Mesh::Helpers::PreferenceProfile.store_mesh_profile(
+          agent_id:        'agent-42',
+          profile:         {
+            verbosity:   :concise,
+            personality: { openness: 0.8, conscientiousness: 0.6 }
+          },
+          source_agent_id: 'agent-42'
+        )
+        result = Legion::Extensions::Mesh::Helpers::PreferenceProfile.for_agent(agent_id: 'agent-42')
+        expect(result[:compatibility]).to be_a(Hash)
+        expect(result[:compatibility][:score]).to eq(0.82)
+        expect(result[:compatibility][:interpretation]).to eq(:compatible)
+      end
+    end
+  end
+
   describe '#expire_pending_requests' do
     it 'cleans up expired entries and returns count' do
       pending_req = runner.send(:pending_requests)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-mesh
 version: !ruby/object:Gem::Version
-  version: 0.3.4
+  version: 0.4.0
 platform: ruby
 authors:
 - Esity