lex-mesh 0.2.5 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 650958df48e1ad4fa390b3fecb3ab2817dc535c279449dc4ce114e92f59cfff2
-  data.tar.gz: ff13ef5a0e18147daa15b72579de24f3691bec50f5f124627d2b503208cfba82
+  metadata.gz: 85f99c905c7878c400b57d6d7e1868838521ab8d2f7f5fad973d6a813c09f411
+  data.tar.gz: b567bb9e7d1defaf1224aa3184fe63c80bc20458fce0d70fb936251e81247634
 SHA512:
-  metadata.gz: fc982147fb2a22e4a5bb40fa8f7a767e87aed754f59474d4937059a831adcfeae6b4f4e4c9add47359c3b6a69200a0cdea21c1bafd1b00dfd74501c93415eb40
-  data.tar.gz: e34a1a0d9ae8481bb40949bda0e47d6e1647856777214d133acf10c121b8e70962bb85c10fda16120b9dd7bc958828fc20a73851ab259c89fa813d7df2236f26
+  metadata.gz: a7b28d8162556724cae30e898607e38633ad7749d98d10a273188c67c203517fb8aff0fa7408e365c2808f1e4dfc95bca5625077187ce7c814cc6ee30e2d5053
+  data.tar.gz: e0e21868a89d6856b83c92d3034aa85d6ba9a1cda02f8afc62a8921c434211e05ad2764395c03b30f3439ca1eb89aa7ae3f616a07e15988b0af28932713f80c2

data/lex-mesh.gemspec

@@ -28,4 +28,12 @@ Gem::Specification.new do |spec|
 
   spec.add_dependency 'base64'
   spec.add_dependency 'ed25519', '~> 1.3'
+
+  spec.add_dependency 'legion-cache',     '>= 1.3.11'
+  spec.add_dependency 'legion-crypt',     '>= 1.4.9'
+  spec.add_dependency 'legion-data',      '>= 1.4.17'
+  spec.add_dependency 'legion-json',      '>= 1.2.1'
+  spec.add_dependency 'legion-logging',   '>= 1.3.2'
+  spec.add_dependency 'legion-settings',  '>= 1.3.14'
+  spec.add_dependency 'legion-transport', '>= 1.3.9'
 end

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/delegation.rb

@@ -66,7 +66,7 @@ module Legion
               detail:       { to: record[:to_agent_id], depth: record[:depth], consent: record[:consent_level] }
             ).publish
           rescue StandardError => e
-            Legion::Logging.warn "[mesh] failed to publish #{event_type}: #{e.message}" if defined?(Legion::Logging)
+            log.warn "[mesh] failed to publish #{event_type}: #{e.message}"
           end
 
           def delegation_tracker

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

@@ -10,25 +10,25 @@ module Legion
 
           def register(agent_id:, capabilities: [], endpoint: nil, **)
             mesh_registry.register_agent(agent_id, capabilities: capabilities, endpoint: endpoint)
-            Legion::Logging.info "[mesh] registered: agent=#{agent_id} capabilities=#{capabilities.join(',')}"
+            log.info "[mesh] registered: agent=#{agent_id} capabilities=#{capabilities.join(',')}"
             { registered: true, agent_id: agent_id }
           end
 
           def unregister(agent_id:, **)
             result = mesh_registry.unregister_agent(agent_id)
             if result
-              Legion::Logging.info "[mesh] unregistered: agent=#{agent_id}"
+              log.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"
+              log.debug "[mesh] unregister failed: agent=#{agent_id} not found"
               { error: :not_found }
             end
           end
 
           def heartbeat(agent_id:, **)
             result = mesh_registry.heartbeat(agent_id)
-            Legion::Logging.debug "[mesh] heartbeat: agent=#{agent_id} alive=#{!result.nil?}"
+            log.debug "[mesh] heartbeat: agent=#{agent_id} alive=#{!result.nil?}"
             result ? { alive: true } : { error: :not_registered }
           end
 
@@ -38,13 +38,13 @@ module Legion
             msg = mesh_registry.route_message(from: from, to: to, capability: capability,
                                               pattern: pattern, payload: payload)
             count = msg[:delivered_to].size
-            Legion::Logging.debug "[mesh] message: from=#{from} pattern=#{pattern} delivered=#{count} to=#{msg[:delivered_to].join(',')}"
+            log.debug "[mesh] message: from=#{from} pattern=#{pattern} delivered=#{count} to=#{msg[:delivered_to].join(',')}"
             { sent: true, delivered_to: msg[:delivered_to], count: count }
           end
 
           def find_agents(capability:, **)
             agents = mesh_registry.find_by_capability(capability)
-            Legion::Logging.debug "[mesh] find: capability=#{capability} found=#{agents.size}"
+            log.debug "[mesh] find: capability=#{capability} found=#{agents.size}"
             { agents: agents.map { |a| a[:agent_id] }, count: agents.size }
           end
 
@@ -52,14 +52,14 @@ module Legion
             online = mesh_registry.online_agents
             total = mesh_registry.count
             msgs = mesh_registry.messages.size
-            Legion::Logging.debug "[mesh] status: total=#{total} online=#{online.size} messages=#{msgs}"
+            log.debug "[mesh] status: total=#{total} online=#{online.size} messages=#{msgs}"
             { 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}"
+              log.info "[mesh] expired silent agent: #{agent_id}"
             end
             { success: true, expired: expired, count: expired.size }
           end
@@ -116,9 +116,9 @@ module Legion
             Legion::Extensions::Mesh::Transport::Messages::MeshDeparture.new(
               agent_id: agent_id, capabilities: capabilities
             ).publish
-            Legion::Logging.debug "[mesh] departure signal published: agent=#{agent_id}"
+            log.debug "[mesh] departure signal published: agent=#{agent_id}"
           rescue StandardError => e
-            Legion::Logging.warn "[mesh] failed to publish departure signal: #{e.message}"
+            log.warn "[mesh] failed to publish departure signal: #{e.message}"
           end
 
           def publish_gossip_message(peers)

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

@@ -75,10 +75,12 @@ module Legion
 
           def local_agent_id
             if defined?(Legion::Settings)
-              Legion::Settings['client']['name']
+              Legion::Settings[:client][:name]
             else
               'unknown'
             end
+          rescue StandardError
+            'unknown'
           end
 
           def publish_preference_response(msg, profile)

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 })
+
+            log.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
+              log.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
+            log.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.1'
     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

data/spec/spec_helper.rb

@@ -1,16 +1,43 @@
 # frozen_string_literal: true
 
 require 'bundler/setup'
+require 'legion/logging'
+require 'legion/settings'
+require 'legion/cache/helper'
+require 'legion/crypt/helper'
+require 'legion/data/helper'
+require 'legion/json/helper'
+require 'legion/transport'
 
 module Legion
-  module Logging
-    def self.debug(_msg); end
-    def self.info(_msg); end
-    def self.warn(_msg); end
-    def self.error(_msg); end
+  module Extensions
+    module Helpers
+      module Lex
+        include Legion::Logging::Helper
+        include Legion::Settings::Helper
+        include Legion::Cache::Helper
+        include Legion::Crypt::Helper
+        include Legion::Data::Helper
+        include Legion::JSON::Helper
+        include Legion::Transport::Helper
+      end
+    end
+
+    module Actors
+      class Every
+        include Helpers::Lex
+      end
+
+      class Once
+        include Helpers::Lex
+      end
+    end
   end
 end
 
+Legion::Settings.loader.settings[:client] ||= {}
+Legion::Settings.loader.settings[:client][:name] = 'test-agent'
+
 require 'legion/extensions/mesh'
 
 RSpec.configure do |config|

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-mesh
 version: !ruby/object:Gem::Version
-  version: 0.2.5
+  version: 0.3.1
 platform: ruby
 authors:
 - Esity
@@ -37,6 +37,104 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: legion-cache
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.11
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.11
+- !ruby/object:Gem::Dependency
+  name: legion-crypt
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.4.9
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.4.9
+- !ruby/object:Gem::Dependency
+  name: legion-data
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.4.17
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.4.17
+- !ruby/object:Gem::Dependency
+  name: legion-json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.2.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.2.1
+- !ruby/object:Gem::Dependency
+  name: legion-logging
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.2
+- !ruby/object:Gem::Dependency
+  name: legion-settings
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.14
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.14
+- !ruby/object:Gem::Dependency
+  name: legion-transport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.9
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.9
 description: Agent-to-agent mesh communication protocol for brain-modeled agentic
   AI
 email:
@@ -63,6 +161,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 +185,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