lex-mesh 0.1.1 → 0.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6b30e6f5f2a0518bde780c8b661c910fe26ec503ddb285ce60883120f8826825
-  data.tar.gz: 456c2c731747543cebb0515abfc44b497382f6c3ca10eb0ad52b21f5816367f8
+  metadata.gz: 75ab8e1dbc78d725a92257640520bfda3f3acb36ae1dc1f1315cc7e8453ca467
+  data.tar.gz: 269027a72a18770e8bf0338fa7c2941bc354546ffc6157bd2533fc258b054baf
 SHA512:
-  metadata.gz: 3b6044cd55148c45c91ce715476a0566a8f2aa6a4aafba4607d0049b80eeffe3578e31ceb6e53a5828b9e857335b0a72a6f4eb3af170fd2ca60c4ce4047da534
-  data.tar.gz: c8002ef1a93733b0e8f7848bf4db6903c90146cd67882d015c6b2d229b3f03dcff3d2abc2fcdeefb0c7b1ab043d1b5a6c172a129475f1044e1063dad6273d63e
+  metadata.gz: 78afa9c435f105a2c18b107d14de0c6d4b9c8850c5181ce394aafe46613c70dedccb24b5b19dbf5ee71f2fa71657905e656d2d4eb916f3429446f0c61398a46d
+  data.tar.gz: 766eb42fd99abaa287af0cd1f48b8daba505f9e4d20dccb927e748cb9734460839915ba2e8513aa8df5bf28817f032f230e08e5bf775f3330d9e4f34d48f47db

data/Gemfile

@@ -6,5 +6,3 @@ gemspec
 
 gem 'rspec', '~> 3.13'
 gem 'rubocop', '~> 1.75', require: false
-
-gem 'legion-gaia', path: '../../legion-gaia'

data/lex-mesh.gemspec

@@ -25,5 +25,4 @@ Gem::Specification.new do |spec|
     Dir.glob('{lib,spec}/**/*') + %w[lex-mesh.gemspec Gemfile]
   end
   spec.require_paths = ['lib']
-  spec.add_development_dependency 'legion-gaia'
 end

data/lib/legion/extensions/mesh/actors/pending_expiry.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/actors/every'
+
+module Legion
+  module Extensions
+    module Mesh
+      module Actor
+        class PendingExpiry < Legion::Extensions::Actors::Every
+          def runner_class
+            Legion::Extensions::Mesh::Runners::Preferences
+          end
+
+          def runner_function
+            'expire_pending_requests'
+          end
+
+          def time
+            30
+          end
+
+          def use_runner?
+            false
+          end
+
+          def check_subtask?
+            false
+          end
+
+          def generate_task?
+            false
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/mesh/actors/preference_listener.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/actors/subscription'
+
+module Legion
+  module Extensions
+    module Mesh
+      module Actor
+        class PreferenceListener < Legion::Extensions::Actors::Subscription
+          def runner_class
+            Legion::Extensions::Mesh::Runners::Preferences
+          end
+
+          def runner_function
+            'dispatch_preference_message'
+          end
+
+          def check_subtask?
+            false
+          end
+
+          def generate_task?
+            false
+          end
+
+          def use_runner?
+            false
+          end
+
+          def queue
+            Legion::Extensions::Mesh::Transport::Queues::Preference
+          end
+
+          def enabled?
+            defined?(Legion::Extensions::Mesh::Runners::Preferences) &&
+              defined?(Legion::Transport)
+          rescue StandardError
+            false
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/mesh/actors/silence_watchdog.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/actors/every'
+
+module Legion
+  module Extensions
+    module Mesh
+      module Actor
+        class SilenceWatchdog < Legion::Extensions::Actors::Every
+          def runner_class
+            Legion::Extensions::Mesh::Runners::Mesh
+          end
+
+          def runner_function
+            'expire_silent_agents'
+          end
+
+          def time
+            15
+          end
+
+          def use_runner?
+            false
+          end
+
+          def check_subtask?
+            false
+          end
+
+          def generate_task?
+            false
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,16 +1,21 @@
 # frozen_string_literal: true
 
+require 'legion/extensions/mesh/runners/mesh'
+require 'legion/extensions/mesh/runners/preferences'
+require 'legion/extensions/mesh/helpers/preference_profile'
+require 'legion/extensions/mesh/helpers/pending_requests'
 require 'legion/extensions/mesh/helpers/topology'
 require 'legion/extensions/mesh/helpers/registry'
-require 'legion/extensions/mesh/runners/mesh'
 
 module Legion
   module Extensions
     module Mesh
       class Client
         include Runners::Mesh
+        include Runners::Preferences
 
-        def initialize(**)
+        def initialize(**opts)
+          @opts = opts
           @mesh_registry = Helpers::Registry.new
         end
 

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

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Mesh
+      module Helpers
+        class PendingRequests
+          def initialize(default_ttl: 5)
+            @default_ttl = default_ttl
+            @requests = {}
+            @mutex = Mutex.new
+          end
+
+          def register(correlation_id:, callback:, ttl: nil)
+            @mutex.synchronize do
+              @requests[correlation_id] = {
+                callback:      callback,
+                registered_at: Time.now,
+                ttl:           ttl || @default_ttl
+              }
+            end
+          end
+
+          def resolve(correlation_id:, result:) # rubocop:disable Naming/PredicateMethod
+            entry = @mutex.synchronize { @requests.delete(correlation_id) }
+            return false unless entry
+
+            entry[:callback]&.call(result)
+            true
+          end
+
+          def pending?(correlation_id)
+            @mutex.synchronize { @requests.key?(correlation_id) }
+          end
+
+          def pending_count
+            @mutex.synchronize { @requests.size }
+          end
+
+          def expire
+            now = Time.now
+            expired = []
+            @mutex.synchronize do
+              @requests.each do |id, entry|
+                next unless now - entry[:registered_at] >= entry[:ttl]
+
+                expired << id
+              end
+              expired.each { |id| @requests.delete(id) }
+            end
+            expired
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -65,6 +65,18 @@ module Legion
             msg
           end
 
+          def expire_silent_agents(timeout: Topology::MESH_SILENCE_TIMEOUT)
+            cutoff = Time.now.utc - timeout
+            expired = []
+            @agents.each_value do |agent|
+              next unless agent[:status] == :online && agent[:last_seen] < cutoff
+
+              agent[:status] = :offline
+              expired << agent[:agent_id]
+            end
+            expired
+          end
+
           def online_agents
             @agents.values.select { |a| a[:status] == :online }
           end

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

@@ -18,6 +18,7 @@ module Legion
             result = mesh_registry.unregister_agent(agent_id)
             if result
               Legion::Logging.info "[mesh] unregistered: agent=#{agent_id}"
+              publish_mesh_departure(agent_id: agent_id, capabilities: result[:capabilities] || [])
               { unregistered: true }
             else
               Legion::Logging.debug "[mesh] unregister failed: agent=#{agent_id} not found"
@@ -55,8 +56,27 @@ module Legion
             { total: total, online: online.size, message_count: msgs }
           end
 
+          def expire_silent_agents(**)
+            expired = mesh_registry.expire_silent_agents
+            expired.each do |agent_id|
+              Legion::Logging.info "[mesh] expired silent agent: #{agent_id}"
+            end
+            { success: true, expired: expired, count: expired.size }
+          end
+
           private
 
+          def publish_mesh_departure(agent_id:, capabilities:)
+            return unless defined?(Legion::Extensions::Mesh::Transport::Messages::MeshDeparture)
+
+            Legion::Extensions::Mesh::Transport::Messages::MeshDeparture.new(
+              agent_id: agent_id, capabilities: capabilities
+            ).publish
+            Legion::Logging.debug "[mesh] departure signal published: agent=#{agent_id}"
+          rescue StandardError => e
+            Legion::Logging.warn "[mesh] failed to publish departure signal: #{e.message}"
+          end
+
           def mesh_registry
             @mesh_registry ||= Helpers::Registry.new
           end

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

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Legion
+  module Extensions
+    module Mesh
+      module Runners
+        module Preferences
+          def query_preferences(target_agent_id:, domains: nil, callback: nil, ttl: 5, **)
+            default_profile = Helpers::PreferenceProfile.resolve(owner_id: target_agent_id)
+
+            return { success: true, source: :local_default, profile: default_profile } unless transport_available?
+
+            correlation_id = SecureRandom.uuid
+            cb = callback || default_preference_callback(target_agent_id: target_agent_id)
+            pending_requests.register(correlation_id: correlation_id, callback: cb, ttl: ttl)
+
+            publish_preference_query(
+              target_agent_id: target_agent_id,
+              correlation_id:  correlation_id,
+              domains:         domains
+            )
+
+            { success: true, source: :pending, correlation_id: correlation_id, profile: default_profile }
+          rescue StandardError => e
+            { success: true, source: :local_default, profile: default_profile, error: e.message }
+          end
+
+          def handle_preference_query(**)
+            owner_id = local_agent_id
+            profile = Helpers::PreferenceProfile.resolve(owner_id: owner_id)
+
+            { success: true, profile: profile, responding_agent_id: local_agent_id }
+          rescue StandardError => e
+            { success: false, error: e.message }
+          end
+
+          def handle_preference_response(correlation_id:, profile:, **)
+            resolved = pending_requests.resolve(correlation_id: correlation_id, result: profile)
+            { resolved: resolved }
+          end
+
+          def expire_pending_requests(**)
+            expired = pending_requests.expire
+            { expired: expired.size, correlation_ids: expired }
+          end
+
+          def dispatch_preference_message(type: nil, **msg)
+            case type
+            when 'preference_query'
+              profile = handle_preference_query(**msg)
+              publish_preference_response(msg, profile) if profile[:success]
+              profile
+            when 'preference_response'
+              handle_preference_response(
+                correlation_id: msg[:correlation_id],
+                profile:        msg[:profile] || {}
+              )
+            else
+              { success: false, error: "unknown preference message type: #{type}" }
+            end
+          end
+
+          private
+
+          def pending_requests
+            @pending_requests ||= Helpers::PendingRequests.new
+          end
+
+          def transport_available?
+            defined?(Legion::Transport::Connection) &&
+              Legion::Transport::Connection.respond_to?(:session)
+          end
+
+          def local_agent_id
+            if defined?(Legion::Settings)
+              Legion::Settings['client']['name']
+            else
+              'unknown'
+            end
+          end
+
+          def publish_preference_response(msg, profile)
+            return unless transport_available?
+
+            Transport::Messages::PreferenceResponse.new(
+              target_agent_id:     msg[:requesting_agent_id],
+              responding_agent_id: local_agent_id,
+              profile:             profile[:profile],
+              correlation_id:      msg[:correlation_id]
+            ).publish
+          rescue StandardError => e
+            log_debug("[mesh] failed to publish preference response: #{e.message}")
+          end
+
+          def publish_preference_query(target_agent_id:, correlation_id:, domains:)
+            Transport::Messages::PreferenceQuery.new(
+              target_agent_id:     target_agent_id,
+              requesting_agent_id: local_agent_id,
+              domains:             domains || [],
+              reply_to:            "agent.#{local_agent_id}.preferences",
+              correlation_id:      correlation_id
+            ).publish
+          end
+
+          def default_preference_callback(target_agent_id:)
+            lambda do |profile|
+              log_debug("[mesh] received preferences for #{target_agent_id}: #{profile.keys.join(', ')}")
+            end
+          end
+
+          def log_debug(msg)
+            Legion::Logging.debug(msg) if defined?(Legion::Logging)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/mesh/transport/messages/mesh_departure.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Mesh
+      module Transport
+        module Messages
+          class MeshDeparture < Legion::Transport::Message
+            def exchange
+              Legion::Transport::Exchanges::Node
+            end
+
+            def routing_key
+              'mesh.departure'
+            end
+
+            def message
+              {
+                type:         'mesh_departure',
+                agent_id:     @options[:agent_id],
+                capabilities: @options[:capabilities] || [],
+                departed_at:  Time.now.to_s
+              }
+            end
+
+            def type
+              'mesh_departure'
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/mesh/transport/messages/preference_query.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Mesh
+      module Transport
+        module Messages
+          class PreferenceQuery < Legion::Transport::Message
+            def exchange
+              Legion::Transport::Exchanges::Agent
+            end
+
+            def routing_key
+              "agent.#{@options[:target_agent_id]}.preferences"
+            end
+
+            def message
+              {
+                type:                'preference_query',
+                requesting_agent_id: @options[:requesting_agent_id],
+                domains:             @options[:domains] || [],
+                requested_at:        Time.now.to_s
+              }
+            end
+
+            def type
+              'preference_query'
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/mesh/transport/messages/preference_response.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Mesh
+      module Transport
+        module Messages
+          class PreferenceResponse < Legion::Transport::Message
+            def exchange
+              Legion::Transport::Exchanges::Agent
+            end
+
+            def routing_key
+              "agent.#{@options[:target_agent_id]}.preferences"
+            end
+
+            def message
+              {
+                type:                'preference_response',
+                responding_agent_id: @options[:responding_agent_id],
+                profile:             @options[:profile] || {},
+                responded_at:        Time.now.to_s
+              }
+            end
+
+            def type
+              'preference_response'
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/mesh/transport/queues/preference.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Mesh
+      module Transport
+        module Queues
+          class Preference < Legion::Transport::Queues::Agent
+            def initialize(agent_id: nil, **)
+              super
+            end
+
+            def queue_name
+              agent = @agent_id || Legion::Settings['client']['name']
+              "agent.#{agent}.preferences"
+            end
+
+            def bind_routing_key
+              agent = @agent_id || Legion::Settings['client']['name']
+              "agent.#{agent}.preferences"
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -3,7 +3,7 @@
 module Legion
   module Extensions
     module Mesh
-      VERSION = '0.1.1'
+      VERSION = '0.2.3'
     end
   end
 end

data/lib/legion/extensions/mesh.rb

@@ -4,7 +4,16 @@ require 'legion/extensions/mesh/version'
 require 'legion/extensions/mesh/helpers/topology'
 require 'legion/extensions/mesh/helpers/registry'
 require 'legion/extensions/mesh/helpers/preference_profile'
+require 'legion/extensions/mesh/helpers/pending_requests'
 require 'legion/extensions/mesh/runners/mesh'
+require 'legion/extensions/mesh/runners/preferences'
+
+if defined?(Legion::Transport)
+  require 'legion/extensions/mesh/transport/messages/preference_query'
+  require 'legion/extensions/mesh/transport/messages/preference_response'
+  require 'legion/extensions/mesh/transport/messages/mesh_departure'
+  require 'legion/extensions/mesh/transport/queues/preference'
+end
 
 module Legion
   module Extensions

data/spec/legion/extensions/mesh/actors/pending_expiry_spec.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+# Stub the framework actor base class
+unless defined?(Legion::Extensions::Actors::Every)
+  module Legion
+    module Extensions
+      module Actors
+        class Every # rubocop:disable Lint/EmptyClass
+        end
+      end
+    end
+  end
+
+  $LOADED_FEATURES << 'legion/extensions/actors/every' unless $LOADED_FEATURES.include?('legion/extensions/actors/every')
+end
+
+require 'legion/extensions/mesh/actors/pending_expiry'
+
+RSpec.describe Legion::Extensions::Mesh::Actor::PendingExpiry do
+  subject(:actor) { described_class.new }
+
+  describe '#runner_class' do
+    it 'returns the Preferences runner module' do
+      expect(actor.runner_class).to eq(Legion::Extensions::Mesh::Runners::Preferences)
+    end
+  end
+
+  describe '#runner_function' do
+    it 'returns expire_pending_requests' do
+      expect(actor.runner_function).to eq('expire_pending_requests')
+    end
+  end
+
+  describe '#time' do
+    it 'returns 30' do
+      expect(actor.time).to eq(30)
+    end
+  end
+
+  describe '#use_runner?' do
+    it 'returns false' do
+      expect(actor.use_runner?).to be false
+    end
+  end
+
+  describe '#check_subtask?' do
+    it 'returns false' do
+      expect(actor.check_subtask?).to be false
+    end
+  end
+
+  describe '#generate_task?' do
+    it 'returns false' do
+      expect(actor.generate_task?).to be false
+    end
+  end
+end