lex-agentic-inference 0.1.1 → 0.1.2

data/lib/legion/extensions/agentic/inference/predictive_coding/runners/predictive_coding.rb

@@ -14,15 +14,15 @@ module Legion
 
               def generate_prediction(domain:, context: {}, **)
                 prediction = generative_model.predict(domain: domain, context: context)
-                Legion::Logging.debug "[predictive_coding] generate_prediction domain=#{domain} " \
-                                      "predicted=#{prediction[:predicted]} confidence=#{prediction[:confidence].round(3)}"
+                log.debug "[predictive_coding] generate_prediction domain=#{domain} " \
+                          "predicted=#{prediction[:predicted]} confidence=#{prediction[:confidence].round(3)}"
                 { success: true, domain: domain, predicted: prediction[:predicted], confidence: prediction[:confidence] }
               end
 
               def report_outcome(domain:, predicted:, actual:, **)
                 error = generative_model.update(domain: domain, predicted: predicted, actual: actual)
-                Legion::Logging.debug "[predictive_coding] report_outcome domain=#{domain} " \
-                                      "error_magnitude=#{error.error_magnitude.round(3)} surprising=#{error.surprising?}"
+                log.debug "[predictive_coding] report_outcome domain=#{domain} " \
+                          "error_magnitude=#{error.error_magnitude.round(3)} surprising=#{error.surprising?}"
                 {
                   success:         true,
                   domain:          domain,
@@ -36,20 +36,20 @@ module Legion
 
               def precision_for(domain:, **)
                 value = generative_model.precision_for(domain: domain)
-                Legion::Logging.debug "[predictive_coding] precision_for domain=#{domain} precision=#{value.round(3)}"
+                log.debug "[predictive_coding] precision_for domain=#{domain} precision=#{value.round(3)}"
                 { success: true, domain: domain, precision: value }
               end
 
               def surprising_errors(**)
                 errors = generative_model.surprising_errors
-                Legion::Logging.debug "[predictive_coding] surprising_errors count=#{errors.size}"
+                log.debug "[predictive_coding] surprising_errors count=#{errors.size}"
                 { success: true, errors: errors.map(&:to_h), count: errors.size }
               end
 
               def free_energy_status(**)
                 fe    = generative_model.free_energy
                 level = generative_model.free_energy_level
-                Legion::Logging.debug "[predictive_coding] free_energy_status fe=#{fe.round(3)} level=#{level}"
+                log.debug "[predictive_coding] free_energy_status fe=#{fe.round(3)} level=#{level}"
                 {
                   success:     true,
                   free_energy: fe,
@@ -60,7 +60,7 @@ module Legion
 
               def active_inference_candidates(**)
                 candidates = generative_model.active_inference_candidates
-                Legion::Logging.debug "[predictive_coding] active_inference_candidates count=#{candidates.size}"
+                log.debug "[predictive_coding] active_inference_candidates count=#{candidates.size}"
                 { success: true, candidates: candidates, count: candidates.size }
               end
 
@@ -77,14 +77,14 @@ module Legion
 
                 prune_active_inferences
 
-                Legion::Logging.debug "[predictive_coding] register_active_inference domain=#{domain} id=#{inference_id[0..7]}"
+                log.debug "[predictive_coding] register_active_inference domain=#{domain} id=#{inference_id[0..7]}"
                 { success: true, inference_id: inference_id, domain: domain, status: :pending }
               end
 
               def resolve_active_inference(domain:, action:, actual_outcome:, inference_id: nil, **)
                 record = find_inference(domain, action, inference_id)
                 unless record
-                  Legion::Logging.debug "[predictive_coding] resolve_active_inference not found domain=#{domain}"
+                  log.debug "[predictive_coding] resolve_active_inference not found domain=#{domain}"
                   return { success: false, reason: :not_found }
                 end
 
@@ -100,8 +100,8 @@ module Legion
                 record[:resolved_at]      = Time.now.utc
                 record[:error_magnitude]  = error.error_magnitude
 
-                Legion::Logging.info "[predictive_coding] resolve_active_inference domain=#{domain} " \
-                                     "error=#{error.error_magnitude.round(3)} id=#{record[:inference_id][0..7]}"
+                log.info "[predictive_coding] resolve_active_inference domain=#{domain} " \
+                         "error=#{error.error_magnitude.round(3)} id=#{record[:inference_id][0..7]}"
 
                 {
                   success:         true,
@@ -115,7 +115,7 @@ module Legion
               def update_predictive_coding(**)
                 generative_model.decay_all
                 pruned = prune_resolved_inferences
-                Legion::Logging.debug "[predictive_coding] update_predictive_coding pruned_inferences=#{pruned}"
+                log.debug "[predictive_coding] update_predictive_coding pruned_inferences=#{pruned}"
                 { success: true, pruned_inferences: pruned }
               end
 

data/lib/legion/extensions/agentic/inference/predictive_processing/runners/predictive_processing.rb

@@ -14,7 +14,7 @@ module Legion
                 return { added: false, reason: :missing_domain } if domain.nil? || domain.to_s.strip.empty?
 
                 result = default_processor.add_model(domain: domain.to_sym)
-                Legion::Logging.debug "[predictive_processing] add_model domain=#{domain} added=#{result[:added]}"
+                log.debug "[predictive_processing] add_model domain=#{domain} added=#{result[:added]}"
                 result
               end
 
@@ -22,8 +22,8 @@ module Legion
                 return { predicted: false, reason: :missing_domain } if domain.nil?
 
                 prediction = default_processor.predict(domain: domain.to_sym, context: context)
-                Legion::Logging.debug "[predictive_processing] predict domain=#{domain} " \
-                                      "expected=#{prediction[:expected_value]&.round(3)}"
+                log.debug "[predictive_processing] predict domain=#{domain} " \
+                          "expected=#{prediction[:expected_value]&.round(3)}"
                 { predicted: true, domain: domain, prediction: prediction }
               end
 
@@ -43,7 +43,7 @@ module Legion
                 return { mode: nil, reason: :missing_domain } if domain.nil?
 
                 mode = default_processor.inference_mode(domain.to_sym)
-                Legion::Logging.debug "[predictive_processing] inference_mode domain=#{domain} mode=#{mode}"
+                log.debug "[predictive_processing] inference_mode domain=#{domain} mode=#{mode}"
                 { domain: domain, mode: mode }
               end
 
@@ -60,25 +60,25 @@ module Legion
 
               def models_needing_update(**)
                 needing = default_processor.models_needing_update
-                Legion::Logging.debug "[predictive_processing] models_needing_update count=#{needing.size}"
+                log.debug "[predictive_processing] models_needing_update count=#{needing.size}"
                 { count: needing.size, models: needing }
               end
 
               def active_inference_candidates(**)
                 candidates = default_processor.active_inference_candidates
-                Legion::Logging.debug "[predictive_processing] active_inference_candidates count=#{candidates.size}"
+                log.debug "[predictive_processing] active_inference_candidates count=#{candidates.size}"
                 { count: candidates.size, domains: candidates }
               end
 
               def update_predictive_processing(**)
                 default_processor.tick
-                Legion::Logging.debug '[predictive_processing] tick: precision decayed on all models'
+                log.debug '[predictive_processing] tick: precision decayed on all models'
                 { ticked: true, model_count: default_processor.models.size }
               end
 
               def predictive_processing_stats(**)
                 stats = default_processor.to_h
-                Legion::Logging.debug "[predictive_processing] stats global_fe=#{stats[:global_free_energy]&.round(3)}"
+                log.debug "[predictive_processing] stats global_fe=#{stats[:global_free_energy]&.round(3)}"
                 { success: true, stats: stats }
               end
 
@@ -91,9 +91,9 @@ module Legion
               def log_observe(domain, result)
                 return unless result[:observed]
 
-                Legion::Logging.debug "[predictive_processing] observe domain=#{domain} " \
-                                      "error=#{result[:prediction_error]&.round(3)} " \
-                                      "mode=#{result[:inference_mode]}"
+                log.debug "[predictive_processing] observe domain=#{domain} " \
+                          "error=#{result[:prediction_error]&.round(3)} " \
+                          "mode=#{result[:inference_mode]}"
               end
             end
           end

data/lib/legion/extensions/agentic/inference/reality_testing/helpers/reality_engine.rb

@@ -7,6 +7,8 @@ module Legion
         module RealityTesting
           module Helpers
             class RealityEngine
+              include Legion::Logging::Helper
+
               def initialize
                 @beliefs     = {}
                 @next_id     = 1
@@ -19,7 +21,7 @@ module Legion
                 @next_id += 1
                 belief = Belief.new(id: id, claim: claim, domain: domain, confidence: confidence)
                 @beliefs[id] = belief
-                Legion::Logging.debug "[reality_testing] create_belief id=#{id} domain=#{domain} confidence=#{confidence.round(2)}"
+                log.debug "[reality_testing] create_belief id=#{id} domain=#{domain} confidence=#{confidence.round(2)}"
                 { created: true, belief: belief.to_h }
               end
 
@@ -28,7 +30,7 @@ module Legion
                 return { tested: false, reason: :not_found } unless belief
 
                 belief.test_with_evidence!(evidence_type: evidence_type, weight: weight)
-                Legion::Logging.debug "[reality_testing] test_belief id=#{belief_id} evidence=#{evidence_type} confidence=#{belief.confidence.round(2)}"
+                log.debug "[reality_testing] test_belief id=#{belief_id} evidence=#{evidence_type} confidence=#{belief.confidence.round(2)}"
                 { tested: true, belief: belief.to_h }
               end
 
@@ -68,7 +70,7 @@ module Legion
                 before = @beliefs.size
                 @beliefs.delete_if { |_id, b| b.confidence < 0.1 }
                 pruned = before - @beliefs.size
-                Legion::Logging.debug "[reality_testing] prune_rejected pruned=#{pruned} remaining=#{@beliefs.size}"
+                log.debug "[reality_testing] prune_rejected pruned=#{pruned} remaining=#{@beliefs.size}"
                 pruned
               end
 

data/lib/legion/extensions/agentic/inference/reality_testing/runners/reality_testing.rb

@@ -13,7 +13,7 @@ module Legion
               def create_belief(claim:, domain: :general, confidence: nil, **)
                 conf   = confidence || Helpers::Constants::DEFAULT_CONFIDENCE
                 result = reality_engine.create_belief(claim: claim, domain: domain, confidence: conf)
-                Legion::Logging.info "[reality_testing] create_belief claim=#{claim[0, 60]} domain=#{domain}"
+                log.info "[reality_testing] create_belief claim=#{claim[0, 60]} domain=#{domain}"
                 result
               end
 
@@ -32,7 +32,7 @@ module Legion
 
               def beliefs_needing_testing(**)
                 beliefs = reality_engine.beliefs_needing_testing
-                Legion::Logging.debug "[reality_testing] needs_testing count=#{beliefs.size}"
+                log.debug "[reality_testing] needs_testing count=#{beliefs.size}"
                 { count: beliefs.size, beliefs: beliefs.map(&:to_h) }
               end
 
@@ -53,13 +53,13 @@ module Legion
 
               def overall_coherence(**)
                 coherence = reality_engine.overall_reality_coherence
-                Legion::Logging.debug "[reality_testing] coherence=#{coherence.round(3)}"
+                log.debug "[reality_testing] coherence=#{coherence.round(3)}"
                 { coherence: coherence.round(3) }
               end
 
               def decay_beliefs(**)
                 count = reality_engine.decay_all
-                Legion::Logging.debug "[reality_testing] decay_all count=#{count}"
+                log.debug "[reality_testing] decay_all count=#{count}"
                 { decayed: count }
               end
 

data/lib/legion/extensions/agentic/inference/schema/runners/schema.rb

@@ -14,8 +14,8 @@ module Legion
                 extract_prediction_outcomes(tick_results)
                 world_model.decay_all
 
-                Legion::Logging.debug "[schema] relations=#{world_model.relation_count} " \
-                                      "domains=#{world_model.domain_count} established=#{world_model.established_relations.size}"
+                log.debug "[schema] relations=#{world_model.relation_count} " \
+                          "domains=#{world_model.domain_count} established=#{world_model.established_relations.size}"
 
                 world_model.to_h
               end
@@ -25,7 +25,7 @@ module Legion
                 result = world_model.add_relation(cause: cause, effect: effect, relation_type: relation_sym, confidence: confidence)
                 return { success: false, error: 'invalid relation type' } unless result
 
-                Legion::Logging.info "[schema] learned: #{cause} #{relation_sym} #{effect} (#{result.confidence.round(2)})"
+                log.info "[schema] learned: #{cause} #{relation_sym} #{effect} (#{result.confidence.round(2)})"
                 { success: true, relation: result.to_h }
               end
 
@@ -33,19 +33,19 @@ module Legion
                 result = world_model.weaken_relation(cause: cause, effect: effect, relation_type: relation_type.to_sym)
                 return { success: false, error: 'relation not found' } unless result
 
-                Legion::Logging.debug "[schema] weakened: #{cause} #{relation_type} #{effect}"
+                log.debug "[schema] weakened: #{cause} #{relation_type} #{effect}"
                 { success: true, relation: result.to_h }
               end
 
               def explain(outcome:, **)
                 chain = world_model.explain(outcome)
-                Legion::Logging.debug "[schema] explanation for #{outcome}: #{chain.size} links"
+                log.debug "[schema] explanation for #{outcome}: #{chain.size} links"
                 { outcome: outcome, chain: chain, depth: chain.size }
               end
 
               def counterfactual(cause:, **)
                 affected = world_model.counterfactual(cause)
-                Legion::Logging.debug "[schema] counterfactual for #{cause}: #{affected.size} effects"
+                log.debug "[schema] counterfactual for #{cause}: #{affected.size} effects"
                 { cause: cause, affected: affected, impact: affected.size }
               end
 
@@ -61,12 +61,12 @@ module Legion
 
               def contradictions(**)
                 result = world_model.contradictions
-                Legion::Logging.debug "[schema] contradictions: #{result.size}"
+                log.debug "[schema] contradictions: #{result.size}"
                 { contradictions: result, count: result.size }
               end
 
               def schema_stats(**)
-                Legion::Logging.debug '[schema] stats'
+                log.debug '[schema] stats'
                 world_model.to_h.merge(
                   top_relations: world_model.established_relations.first(10).map(&:to_h)
                 )

data/lib/legion/extensions/agentic/inference/uncertainty_tolerance/runners/uncertainty_tolerance.rb

@@ -16,9 +16,9 @@ module Legion
                   domain:          domain,
                   certainty_level: certainty_level
                 )
-                Legion::Logging.debug "[uncertainty_tolerance] recorded decision: id=#{decision.id[0..7]} " \
-                                      "domain=#{domain} certainty=#{certainty_level.round(2)} " \
-                                      "type=#{decision.decision_type}"
+                log.debug "[uncertainty_tolerance] recorded decision: id=#{decision.id[0..7]} " \
+                          "domain=#{domain} certainty=#{certainty_level.round(2)} " \
+                          "type=#{decision.decision_type}"
                 {
                   decision_id:               decision.id,
                   domain:                    domain,
@@ -32,12 +32,12 @@ module Legion
               def resolve_uncertain_decision(decision_id:, outcome:, **)
                 decision = engine.resolve_decision(decision_id: decision_id, outcome: outcome)
                 unless decision
-                  Legion::Logging.debug "[uncertainty_tolerance] resolve failed: #{decision_id[0..7]} not found"
+                  log.debug "[uncertainty_tolerance] resolve failed: #{decision_id[0..7]} not found"
                   return { resolved: false, reason: :not_found }
                 end
 
-                Legion::Logging.info "[uncertainty_tolerance] resolved: id=#{decision_id[0..7]} " \
-                                     "outcome=#{outcome} tolerance=#{engine.current_tolerance.round(3)}"
+                log.info "[uncertainty_tolerance] resolved: id=#{decision_id[0..7]} " \
+                         "outcome=#{outcome} tolerance=#{engine.current_tolerance.round(3)}"
                 {
                   resolved:          true,
                   decision_id:       decision_id,
@@ -50,8 +50,8 @@ module Legion
               def should_act_assessment(certainty:, **)
                 act = engine.should_act?(certainty: certainty)
                 gap = (certainty - engine.current_tolerance).round(3)
-                Legion::Logging.debug "[uncertainty_tolerance] should_act? certainty=#{certainty.round(2)} " \
-                                      "tolerance=#{engine.current_tolerance.round(2)} act=#{act}"
+                log.debug "[uncertainty_tolerance] should_act? certainty=#{certainty.round(2)} " \
+                          "tolerance=#{engine.current_tolerance.round(2)} act=#{act}"
                 {
                   should_act:        act,
                   certainty:         certainty,
@@ -63,14 +63,14 @@ module Legion
 
               def uncertainty_profile(**)
                 profile = engine.to_h
-                Legion::Logging.debug "[uncertainty_tolerance] profile: tolerance=#{profile[:current_tolerance].round(3)} " \
-                                      "label=#{profile[:tolerance_label]} decisions=#{profile[:total_decisions]}"
+                log.debug "[uncertainty_tolerance] profile: tolerance=#{profile[:current_tolerance].round(3)} " \
+                          "label=#{profile[:tolerance_label]} decisions=#{profile[:total_decisions]}"
                 profile
               end
 
               def decisions_under_uncertainty_report(threshold: nil, **)
                 decisions = engine.decisions_under_uncertainty(threshold: threshold)
-                Legion::Logging.debug "[uncertainty_tolerance] under_uncertainty: count=#{decisions.size}"
+                log.debug "[uncertainty_tolerance] under_uncertainty: count=#{decisions.size}"
                 {
                   decisions: decisions.map(&:to_h),
                   count:     decisions.size,
@@ -80,7 +80,7 @@ module Legion
 
               def domain_tolerance_report(domain:, **)
                 avg = engine.domain_tolerance(domain: domain)
-                Legion::Logging.debug "[uncertainty_tolerance] domain_tolerance: domain=#{domain} avg=#{avg&.round(3)}"
+                log.debug "[uncertainty_tolerance] domain_tolerance: domain=#{domain} avg=#{avg&.round(3)}"
                 {
                   domain:            domain,
                   average_certainty: avg,
@@ -94,8 +94,8 @@ module Legion
                   Helpers::Constants::TOLERANCE_CEILING
                 )
                 engine.instance_variable_set(:@current_tolerance, clamped)
-                Legion::Logging.info "[uncertainty_tolerance] tolerance updated: #{clamped.round(3)} " \
-                                     "label=#{engine.tolerance_label}"
+                log.info "[uncertainty_tolerance] tolerance updated: #{clamped.round(3)} " \
+                         "label=#{engine.tolerance_label}"
                 {
                   updated:           true,
                   current_tolerance: clamped,

data/lib/legion/extensions/agentic/inference/version.rb

@@ -4,7 +4,7 @@ module Legion
   module Extensions
     module Agentic
       module Inference
-        VERSION = '0.1.1'
+        VERSION = '0.1.2'
       end
     end
   end

data/spec/spec_helper.rb

@@ -1,41 +1,39 @@
 # 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
-    def self.fatal(_msg); end
-  end
-
   module Extensions
-    module Core
-      def self.extended(_base); end
-    end
-
     module Helpers
       module Lex
-        def self.included(_base); end
+        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
-  end
-end
 
-# rubocop:disable Lint/EmptyClass, Style/OneClassPerFile
-module Legion
-  module Extensions
     module Actors
-      class Every; end
-      class Once; end
+      class Every
+        include Helpers::Lex
+      end
+
+      class Subscription
+        include Helpers::Lex
+      end
     end
   end
 end
-$LOADED_FEATURES << 'legion/extensions/actors/every'
-$LOADED_FEATURES << 'legion/extensions/actors/once'
-# rubocop:enable Lint/EmptyClass, Style/OneClassPerFile
 
 require 'legion/extensions/agentic/inference'
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-agentic-inference
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Esity
@@ -9,6 +9,104 @@ bindir: bin
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
+- !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
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement