lex-mesh 0.2.5 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 650958df48e1ad4fa390b3fecb3ab2817dc535c279449dc4ce114e92f59cfff2
-  data.tar.gz: ff13ef5a0e18147daa15b72579de24f3691bec50f5f124627d2b503208cfba82
+  metadata.gz: d736de5644beff024c6acc40ededd1eface48a64dc919b4f1033e0971a7af71f
+  data.tar.gz: e58b0661aab721ebaf1c7f413691a41f2a5f0f1e455710b3d27f79ad687655fb
 SHA512:
-  metadata.gz: fc982147fb2a22e4a5bb40fa8f7a767e87aed754f59474d4937059a831adcfeae6b4f4e4c9add47359c3b6a69200a0cdea21c1bafd1b00dfd74501c93415eb40
-  data.tar.gz: e34a1a0d9ae8481bb40949bda0e47d6e1647856777214d133acf10c121b8e70962bb85c10fda16120b9dd7bc958828fc20a73851ab259c89fa813d7df2236f26
+  metadata.gz: d1abfff1fe01a29d3b9be8ee75c5f949f753a9fdf33df340e1362ef758236fb411a826eb0ae3c448bc330b8bc06cff725f35d10b5767f39ca7a8ffcb06969782
+  data.tar.gz: e1266fc12dd23f183439f2ed5c1d2a21a1c11b824652e918b6fc398df40eea46cc5aa0dbabbb14e99b8f41aa4b0cd2e99d71a259aaba8de595088c51336c7a62

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

@@ -2,6 +2,8 @@
 
 require 'legion/extensions/mesh/runners/mesh'
 require 'legion/extensions/mesh/runners/preferences'
+require 'legion/extensions/mesh/runners/delegation'
+require 'legion/extensions/mesh/runners/task_request'
 require 'legion/extensions/mesh/helpers/preference_profile'
 require 'legion/extensions/mesh/helpers/pending_requests'
 require 'legion/extensions/mesh/helpers/topology'
@@ -13,6 +15,8 @@ module Legion
       class Client
         include Runners::Mesh
         include Runners::Preferences
+        include Runners::Delegation
+        include Runners::TaskRequest
 
         def initialize(**opts)
           @opts = opts

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

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+require_relative '../helpers/pending_requests'
+require_relative '../helpers/delegation'
+require_relative '../helpers/registry'
+require_relative 'mesh'
+
+module Legion
+  module Extensions
+    module Mesh
+      module Runners
+        module TaskRequest
+          include Runners::Mesh
+
+          DEFAULT_TIMEOUT = 30
+
+          def request_task(from:, to:, task:, payload:, timeout: DEFAULT_TIMEOUT, consent_level: :execute, **) # rubocop:disable Metrics/ParameterLists
+            target_id = resolve_target(to)
+            return { success: false, reason: :no_agent_found, requested: to } unless target_id
+
+            correlation_id = "task-#{SecureRandom.uuid}"
+
+            delegation = delegation_tracker.create(
+              from: from, to: target_id,
+              task_context: task, consent_level: consent_level
+            )
+            return { success: false, reason: delegation[:error] } if delegation[:error]
+
+            task_pending.register(
+              correlation_id: correlation_id,
+              callback:       nil,
+              ttl:            timeout
+            )
+
+            send_message(from: from, to: target_id, pattern: :unicast,
+                         payload: { type: :task_request, correlation_id: correlation_id,
+                                    task: task, payload: payload, reply_to: from })
+
+            Legion::Logging.info "[mesh-task] request: from=#{from} to=#{target_id} task=#{task} cid=#{correlation_id[0..11]}"
+            { success: true, correlation_id: correlation_id, delegation_id: delegation[:delegation_id],
+              target_agent: target_id }
+          end
+
+          def handle_task_reply(correlation_id:, result:, **)
+            resolved = task_pending.resolve(correlation_id: correlation_id, result: result)
+            if resolved
+              Legion::Logging.debug "[mesh-task] reply resolved: cid=#{correlation_id[0..11]}"
+              { success: true, resolved: true, correlation_id: correlation_id }
+            else
+              { success: false, reason: :not_found, correlation_id: correlation_id }
+            end
+          end
+
+          def pending_task_stats(**)
+            { success: true, pending_count: task_pending.pending_count }
+          end
+
+          def expire_pending_tasks(**)
+            expired = task_pending.expire
+            Legion::Logging.debug "[mesh-task] expired #{expired.size} pending tasks" unless expired.empty?
+            { success: true, expired_count: expired.size, expired_ids: expired }
+          end
+
+          private
+
+          def resolve_target(to)
+            return to if mesh_registry.agents.key?(to)
+
+            agents = mesh_registry.find_by_capability(to.to_sym)
+            return nil if agents.empty?
+
+            online = agents.select { |a| a[:status] == :online }
+            (online.empty? ? agents : online).sample[:agent_id]
+          end
+
+          def task_pending
+            @task_pending ||= Helpers::PendingRequests.new(default_ttl: DEFAULT_TIMEOUT)
+          end
+
+          def delegation_tracker
+            @delegation_tracker ||= Helpers::Delegation.new
+          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.2.5'
+      VERSION = '0.3.0'
     end
   end
 end

data/lib/legion/extensions/mesh.rb

@@ -10,6 +10,7 @@ require 'legion/extensions/mesh/helpers/peer_verify'
 require 'legion/extensions/mesh/runners/mesh'
 require 'legion/extensions/mesh/runners/preferences'
 require 'legion/extensions/mesh/runners/delegation'
+require 'legion/extensions/mesh/runners/task_request'
 
 if defined?(Legion::Transport)
   require 'legion/extensions/mesh/transport/messages/preference_query'

data/spec/legion/extensions/mesh/client_spec.rb

@@ -51,4 +51,26 @@ RSpec.describe Legion::Extensions::Mesh::Client do
       expect(result[:expired]).to eq(0)
     end
   end
+
+  it 'responds to delegation runner methods' do
+    expect(client).to respond_to(:delegate)
+    expect(client).to respond_to(:complete_delegation)
+    expect(client).to respond_to(:revoke_delegation)
+  end
+
+  it 'responds to task request runner methods' do
+    expect(client).to respond_to(:request_task)
+    expect(client).to respond_to(:handle_task_reply)
+    expect(client).to respond_to(:pending_task_stats)
+  end
+
+  describe '#request_task' do
+    it 'sends a task request via the client' do
+      client.register(agent_id: 'a', capabilities: [:orchestration])
+      client.register(agent_id: 'b', capabilities: [:review])
+      result = client.request_task(from: 'a', to: 'b', task: 'review', payload: {})
+      expect(result[:success]).to be true
+      expect(result[:target_agent]).to eq('b')
+    end
+  end
 end

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

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'legion/extensions/mesh/runners/task_request'
+
+RSpec.describe Legion::Extensions::Mesh::Runners::TaskRequest do
+  subject(:runner) { Object.new.extend(described_class) }
+
+  before do
+    runner.instance_variable_set(:@mesh_registry, nil)
+    runner.instance_variable_set(:@task_pending, nil)
+    runner.instance_variable_set(:@delegation_tracker, nil)
+  end
+
+  describe '#request_task' do
+    before do
+      runner.register(agent_id: 'requester', capabilities: [:orchestration])
+      runner.register(agent_id: 'worker-1', capabilities: [:code_review])
+      runner.register(agent_id: 'worker-2', capabilities: %i[code_review testing])
+    end
+
+    it 'sends a task request to a specific agent by ID' do
+      result = runner.request_task(from: 'requester', to: 'worker-1',
+                                   task: 'review_code', payload: { file: 'app.rb' })
+      expect(result[:success]).to be true
+      expect(result[:correlation_id]).to be_a(String)
+      expect(result[:delegation_id]).to start_with('del-')
+      expect(result[:target_agent]).to eq('worker-1')
+    end
+
+    it 'routes to an agent by capability when to: is not a registered agent' do
+      result = runner.request_task(from: 'requester', to: 'code_review',
+                                   task: 'review_code', payload: {})
+      expect(result[:success]).to be true
+      expect(%w[worker-1 worker-2]).to include(result[:target_agent])
+    end
+
+    it 'returns error when no agent found for capability' do
+      result = runner.request_task(from: 'requester', to: 'nonexistent_capability',
+                                   task: 'do_thing', payload: {})
+      expect(result[:success]).to be false
+      expect(result[:reason]).to eq(:no_agent_found)
+    end
+
+    it 'registers a pending request' do
+      result = runner.request_task(from: 'requester', to: 'worker-1',
+                                   task: 'review', payload: {}, timeout: 60)
+      expect(runner.send(:task_pending).pending?(result[:correlation_id])).to be true
+    end
+  end
+
+  describe '#handle_task_reply' do
+    it 'resolves a pending request' do
+      runner.register(agent_id: 'req', capabilities: [])
+      runner.register(agent_id: 'wrk', capabilities: [:work])
+
+      req = runner.request_task(from: 'req', to: 'wrk', task: 'test', payload: {})
+      result = runner.handle_task_reply(
+        correlation_id: req[:correlation_id],
+        result:         { status: :completed, output: 'done' }
+      )
+      expect(result[:success]).to be true
+      expect(result[:resolved]).to be true
+    end
+
+    it 'returns not_found for unknown correlation_id' do
+      result = runner.handle_task_reply(correlation_id: 'unknown', result: {})
+      expect(result[:success]).to be false
+      expect(result[:reason]).to eq(:not_found)
+    end
+  end
+
+  describe '#pending_task_stats' do
+    it 'returns count of pending requests' do
+      runner.register(agent_id: 'a', capabilities: [])
+      runner.register(agent_id: 'b', capabilities: [:work])
+      runner.request_task(from: 'a', to: 'b', task: 't', payload: {})
+      stats = runner.pending_task_stats
+      expect(stats[:success]).to be true
+      expect(stats[:pending_count]).to be >= 1
+    end
+  end
+
+  describe '#expire_pending_tasks' do
+    it 'expires timed-out requests' do
+      result = runner.expire_pending_tasks
+      expect(result[:success]).to be true
+      expect(result[:expired_count]).to eq(0)
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-mesh
 version: !ruby/object:Gem::Version
-  version: 0.2.5
+  version: 0.3.0
 platform: ruby
 authors:
 - Esity
@@ -63,6 +63,7 @@ files:
 - lib/legion/extensions/mesh/runners/delegation.rb
 - lib/legion/extensions/mesh/runners/mesh.rb
 - lib/legion/extensions/mesh/runners/preferences.rb
+- lib/legion/extensions/mesh/runners/task_request.rb
 - lib/legion/extensions/mesh/transport/messages/gossip.rb
 - lib/legion/extensions/mesh/transport/messages/mesh_departure.rb
 - lib/legion/extensions/mesh/transport/messages/preference_query.rb
@@ -86,6 +87,7 @@ files:
 - spec/legion/extensions/mesh/runners/mesh_gossip_spec.rb
 - spec/legion/extensions/mesh/runners/mesh_spec.rb
 - spec/legion/extensions/mesh/runners/preferences_spec.rb
+- spec/legion/extensions/mesh/runners/task_request_spec.rb
 - spec/legion/extensions/mesh/transport/messages/gossip_spec.rb
 - spec/legion/extensions/mesh/transport/messages/mesh_departure_spec.rb
 - spec/legion/extensions/mesh/transport/messages/preference_query_spec.rb