lex-apollo 0.4.22 → 0.4.24

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9a3e0ff5897e31c3f8e91f5b71eb96fd9ee90a15a041a5034ae936e2188806ae
-  data.tar.gz: c3aba4e4e156c940298dde9c54da46b77e87ffa05db60b7f4b3877307fa20c1c
+  metadata.gz: 2dceee29e5b2af12bab5833beac8b837d2366eaf9509c7e4ce04e88b44a5c28f
+  data.tar.gz: 97d62a6385f375b19a6f48b1881fef8525e5949c4348bfe0cd07581d9ff710f2
 SHA512:
-  metadata.gz: e8d3000ec6c34b23c5f49eea11b2a03d8ef117d395f9134782cf1c2fe91650b569b036571aaafd023d36d3fbd74725d492e44b98ed701348717b3221a7e45986
-  data.tar.gz: 811fd837e8370dde5d998daadad819f648da2f4b1aae3258c82573efb773a4901c6aff8b6cbcbe60eb9f964cee9146b81288d923429321cc7e70e046cd14371b
+  metadata.gz: 90065729231f3322eeaaeaa0e44e03b9b79350157674bec30f174fa6447d74bc53b4794e3385eee9d617c13c62cb22198de39fc21ebece7d2d512e7b1dd09ba6
+  data.tar.gz: f1c1b607fd9d9d244c0937b654ea95ca361980f5732c6e513719a6163004595ce0aaa9baab4181db56c8e6e8d1c511c1d6695c9110905e2094a252ba06e5a2c6

data/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog
 
+## [0.4.24] - 2026-05-07
+
+### Fixed
+- Prevent zero-vector embeddings from being stored as valid semantic vectors when LLM embedding is unavailable.
+- Avoid self-referential corroboration relations, bound corroboration maintenance scans, and preserve valid decay age filtering.
+- Parse structured GAS LLM phase responses from `result[:data]` before falling back to JSON strings.
+- Make Apollo write-privilege memoization thread-safe.
+
+## [0.4.23] - 2026-05-06
+
+### Fixed
+- Apollo data model access now prefers the namespaced `Legion::Data::Model::Apollo::*` classes introduced by the legion-data schema cleanup while retaining fallback compatibility with the legacy `ApolloEntry`, `ApolloRelation`, `ApolloAccessLog`, and `ApolloExpertise` constants.
+
+### Changed
+- Apollo defaults are now declared directly in `Apollo.default_settings`, and Apollo helpers, runners, actors, and API paths use `Legion::Logging::Helper`, `Legion::Settings::Helper`, and `Legion::JSON` helper methods instead of direct logging/settings/JSON calls.
+
 ## [0.4.22] - 2026-04-28
 
 ### Fixed

data/lib/legion/extensions/apollo/actors/corroboration_checker.rb

@@ -8,9 +8,11 @@ module Legion
     module Apollo
       module Actor
         class CorroborationChecker < Legion::Extensions::Actors::Every
+          include Legion::Settings::Helper
+
           def runner_class    = Legion::Extensions::Apollo::Runners::Maintenance
           def runner_function = 'check_corroboration'
-          def time            = (defined?(Legion::Settings) && Legion::Settings.dig(:apollo, :actors, :corroboration_interval)) || 900
+          def time            = settings[:actors][:corroboration_interval]
           def run_now?        = false
           def use_runner?     = false
           def check_subtask?  = false

data/lib/legion/extensions/apollo/actors/decay.rb

@@ -8,9 +8,11 @@ module Legion
     module Apollo
       module Actor
         class Decay < Legion::Extensions::Actors::Every
+          include Legion::Settings::Helper
+
           def runner_class    = Legion::Extensions::Apollo::Runners::Maintenance
           def runner_function = 'run_decay_cycle'
-          def time            = (defined?(Legion::Settings) && Legion::Settings.dig(:apollo, :actors, :decay_interval)) || 3600
+          def time            = settings[:actors][:decay_interval]
           def run_now?        = false
           def use_runner?     = false
           def check_subtask?  = false

data/lib/legion/extensions/apollo/actors/entity_watchdog.rb

@@ -11,6 +11,7 @@ module Legion
         class EntityWatchdog < Legion::Extensions::Actors::Every
           include Legion::Extensions::Apollo::Runners::Knowledge
           include Legion::Extensions::Apollo::Runners::EntityExtractor
+          include Legion::Settings::Helper
 
           DEDUP_THRESHOLD_DEFAULT   = 0.92
           TASK_LOG_LOOKBACK_SECONDS = 300
@@ -18,7 +19,7 @@ module Legion
 
           def runner_class    = self.class
           def runner_function = 'scan_and_ingest'
-          def time            = (defined?(Legion::Settings) && Legion::Settings.dig(:apollo, :actors, :entity_watchdog_interval)) || 120
+          def time            = settings[:actors][:entity_watchdog_interval]
           def run_now?        = false
           def use_runner?     = false
           def check_subtask?  = false
@@ -28,7 +29,7 @@ module Legion
             defined?(Legion::Extensions::Apollo::Runners::EntityExtractor) &&
               Legion.const_defined?(:Transport, false)
           rescue StandardError => e
-            log.warn("EntityWatchdog enabled? check failed: #{e.message}")
+            handle_exception(e, level: :warn, operation: 'apollo.entity_watchdog.enabled')
             false
           end
 
@@ -64,8 +65,8 @@ module Legion
           def recent_task_log_texts
             return [] unless defined?(Legion::Data) && defined?(Legion::Data::Model::TaskLog)
 
-            lookback = (defined?(Legion::Settings) && Legion::Settings.dig(:apollo, :entity_watchdog, :lookback_seconds)) || TASK_LOG_LOOKBACK_SECONDS
-            log_limit = (defined?(Legion::Settings) && Legion::Settings.dig(:apollo, :entity_watchdog, :log_limit)) || TASK_LOG_LIMIT
+            lookback = settings[:entity_watchdog][:lookback_seconds]
+            log_limit = settings[:entity_watchdog][:log_limit]
             cutoff = Time.now - lookback
             logs = Legion::Data::Model::TaskLog
                    .where { created_at >= cutoff }
@@ -76,7 +77,7 @@ module Legion
             log.debug("EntityWatchdog recent_task_log_texts lookback=#{lookback} limit=#{log_limit} raw=#{logs.size} unique=#{texts.size}")
             texts
           rescue StandardError => e
-            log.warn("EntityWatchdog recent_task_log_texts failed: #{e.message}")
+            handle_exception(e, level: :warn, operation: 'apollo.entity_watchdog.recent_task_log_texts')
             []
           end
 
@@ -93,7 +94,7 @@ module Legion
             distance = closest[:distance].to_f
             distance <= (1.0 - dedup_similarity_threshold)
           rescue StandardError => e
-            log.warn("EntityWatchdog entity_exists_in_apollo? failed: #{e.message}")
+            handle_exception(e, level: :warn, operation: 'apollo.entity_watchdog.entity_exists_in_apollo')
             false
           end
 
@@ -113,27 +114,15 @@ module Legion
           end
 
           def entity_types
-            if defined?(Legion::Settings)
-              types = Legion::Settings.dig(:apollo, :entity_watchdog, :types)
-              return Array(types).map(&:to_s) if types
-            end
-            %w[person service repository concept]
+            Array(settings[:entity_watchdog][:types]).map(&:to_s)
           end
 
           def min_entity_confidence
-            if defined?(Legion::Settings)
-              val = Legion::Settings.dig(:apollo, :entity_watchdog, :min_confidence)
-              return val.to_f if val
-            end
-            0.7
+            settings[:entity_watchdog][:min_confidence].to_f
           end
 
           def dedup_similarity_threshold
-            if defined?(Legion::Settings)
-              val = Legion::Settings.dig(:apollo, :entity_watchdog, :dedup_threshold)
-              return val.to_f if val
-            end
-            DEDUP_THRESHOLD_DEFAULT
+            settings[:entity_watchdog][:dedup_threshold].to_f
           end
         end
       end

data/lib/legion/extensions/apollo/actors/expertise_aggregator.rb

@@ -8,9 +8,11 @@ module Legion
     module Apollo
       module Actor
         class ExpertiseAggregator < Legion::Extensions::Actors::Every
+          include Legion::Settings::Helper
+
           def runner_class    = Legion::Extensions::Apollo::Runners::Expertise
           def runner_function = 'aggregate'
-          def time            = (defined?(Legion::Settings) && Legion::Settings.dig(:apollo, :actors, :expertise_interval)) || 1800
+          def time            = settings[:actors][:expertise_interval]
           def run_now?        = false
           def use_runner?     = false
           def check_subtask?  = false

data/lib/legion/extensions/apollo/actors/gas_subscriber.rb

@@ -17,7 +17,7 @@ module Legion
             defined?(Legion::Extensions::Apollo::Runners::Gas) &&
               Legion.const_defined?(:Transport, false)
           rescue StandardError => e
-            log.warn("GasSubscriber enabled? check failed: #{e.message}")
+            handle_exception(e, level: :warn, operation: 'apollo.gas_subscriber.enabled')
             false
           end
 

data/lib/legion/extensions/apollo/actors/ingest.rb

@@ -16,7 +16,7 @@ module Legion
             defined?(Legion::Extensions::Apollo::Runners::Knowledge) &&
               Legion.const_defined?(:Transport, false)
           rescue StandardError => e
-            log.warn("Ingest enabled? check failed: #{e.message}")
+            handle_exception(e, level: :warn, operation: 'apollo.ingest.enabled')
             false
           end
         end

data/lib/legion/extensions/apollo/actors/query_responder.rb

@@ -16,7 +16,7 @@ module Legion
             defined?(Legion::Extensions::Apollo::Runners::Knowledge) &&
               Legion.const_defined?(:Transport, false)
           rescue StandardError => e
-            log.warn("QueryResponder enabled? check failed: #{e.message}")
+            handle_exception(e, level: :warn, operation: 'apollo.query_responder.enabled')
             false
           end
         end

data/lib/legion/extensions/apollo/actors/writeback_store.rb

@@ -17,7 +17,7 @@ module Legion
               Legion.const_defined?(:Transport, false) &&
               Helpers::Capability.apollo_write_enabled?
           rescue StandardError => e
-            log.warn("WritebackStore enabled? check failed: #{e.message}")
+            handle_exception(e, level: :warn, operation: 'apollo.writeback_store.enabled')
             false
           end
         end

data/lib/legion/extensions/apollo/actors/writeback_vectorize.rb

@@ -15,7 +15,7 @@ module Legion
           def handle_vectorize(payload)
             payload = symbolize(payload)
             log.debug("WritebackVectorize handle_vectorize content_length=#{payload[:content].to_s.length} content_type=#{payload[:content_type] || 'nil'}")
-            result = Legion::LLM::Embeddings.generate(text: payload[:content])
+            result = Legion::LLM::Call::Embeddings.generate(text: payload[:content])
             vector = result.is_a?(Hash) ? result[:vector] : result
             embedding = vector.is_a?(Array) && vector.any? ? vector : Array.new(1024, 0.0)
             log.debug("WritebackVectorize embedding_dimensions=#{embedding.length} vector_generated=#{vector.is_a?(Array) && vector.any?}")
@@ -41,7 +41,7 @@ module Legion
           def enabled? # rubocop:disable Legion/Extension/ActorEnabledSideEffects
             Legion.const_defined?(:Transport, false) && Helpers::Capability.can_embed?
           rescue StandardError => e
-            log.warn("WritebackVectorize enabled? check failed: #{e.message}")
+            handle_exception(e, level: :warn, operation: 'apollo.writeback_vectorize.enabled')
             false
           end
 

data/lib/legion/extensions/apollo/api.rb

@@ -1,7 +1,9 @@
 # frozen_string_literal: true
 
 require 'sinatra/base' unless defined?(Sinatra)
-require 'json'
+require 'legion/logging'
+require 'legion/json'
+require 'legion/extensions/apollo/helpers/data_models'
 
 module Legion
   module Extensions
@@ -11,9 +13,9 @@ module Legion
 
         class << self
           def stats_payload(now: Time.now)
-            return { error: 'apollo_data_not_available' } unless defined?(Legion::Data::Model::ApolloEntry)
+            return { error: 'apollo_data_not_available' } unless Helpers::DataModels.apollo_entry_available?
 
-            entries = Legion::Data::Model::ApolloEntry
+            entries = Helpers::DataModels.apollo_entry
             by_status = grouped_counts(entries, :status)
             by_status['active'] = entries.exclude(status: 'archived').count
 
@@ -24,7 +26,7 @@ module Legion
               by_status:       by_status,
               by_content_type: grouped_counts(entries, :content_type)
             }
-            stats[:total_relations] = Legion::Data::Model::ApolloRelation.count if defined?(Legion::Data::Model::ApolloRelation)
+            stats[:total_relations] = Helpers::DataModels.apollo_relation.count if Helpers::DataModels.apollo_relation_available?
             stats
           end
 
@@ -45,13 +47,17 @@ module Legion
         end
 
         helpers do
+          include Legion::Logging::Helper
+          include Legion::JSON::Helper
+
           def json_body
             body = request.body.read
             return {} if body.empty?
 
-            ::JSON.parse(body, symbolize_names: true)
-          rescue ::JSON::ParserError => e
-            halt 400, { error: "invalid JSON: #{e.message}" }.to_json
+            json_parse(body)
+          rescue Legion::JSON::ParseError => e
+            handle_exception(e, level: :warn, operation: 'apollo.api.json_body')
+            halt 400, json_dump(error: "invalid JSON: #{e.message}")
           end
 
           def runner
@@ -73,14 +79,14 @@ module Legion
 
         # Health check
         get '/api/apollo/health' do
-          available = defined?(Legion::Data::Model::ApolloEntry) ? true : false
-          { status: available ? 'ok' : 'degraded', data_available: available }.to_json
+          available = Helpers::DataModels.apollo_entry_available?
+          json_dump(status: available ? 'ok' : 'degraded', data_available: available)
         end
 
         # Query knowledge (semantic search)
         post '/api/apollo/query' do
           req = json_body
-          halt 400, { error: 'query is required' }.to_json unless req[:query]
+          halt 400, json_dump(error: 'query is required') unless req[:query]
 
           query_options = {
             query:          req[:query],
@@ -94,14 +100,14 @@ module Legion
 
           result = runner.handle_query(**query_options)
           status result[:success] ? 200 : 500
-          result.to_json
+          json_dump(result)
         end
 
         # Ingest knowledge
         post '/api/apollo/ingest' do
           req = json_body
-          halt 400, { error: 'content is required' }.to_json unless req[:content]
-          halt 400, { error: 'content_type is required' }.to_json unless req[:content_type]
+          halt 400, json_dump(error: 'content is required') unless req[:content]
+          halt 400, json_dump(error: 'content_type is required') unless req[:content_type]
 
           result = runner.handle_ingest(
             content:          req[:content],
@@ -114,13 +120,13 @@ module Legion
             context:          req[:context] || {}
           )
           status result[:success] ? 201 : 500
-          result.to_json
+          json_dump(result)
         end
 
         # Graph traversal
         post '/api/apollo/traverse' do
           req = json_body
-          halt 400, { error: 'entry_id is required' }.to_json unless req[:entry_id]
+          halt 400, json_dump(error: 'entry_id is required') unless req[:entry_id]
 
           result = runner.handle_traverse(
             entry_id:       req[:entry_id],
@@ -129,13 +135,13 @@ module Legion
             agent_id:       req[:agent_id] || 'api'
           )
           status result[:success] ? 200 : 500
-          result.to_json
+          json_dump(result)
         end
 
         # Retrieve relevant (GAIA-compatible)
         post '/api/apollo/retrieve' do
           req = json_body
-          halt 400, { error: 'query is required' }.to_json unless req[:query]
+          halt 400, json_dump(error: 'query is required') unless req[:query]
 
           result = runner.retrieve_relevant(
             query:          req[:query],
@@ -145,7 +151,7 @@ module Legion
             domain:         req[:domain]
           )
           status result[:success] ? 200 : 500
-          result.to_json
+          json_dump(result)
         end
 
         # Deprecate entry
@@ -154,24 +160,24 @@ module Legion
             entry_id: params[:id],
             reason:   json_body[:reason] || 'deprecated via API'
           )
-          result.to_json
+          json_dump(result)
         end
 
         # Domains at risk — must be declared before /:agent_id to avoid routing conflict
         get '/api/apollo/expertise/at-risk' do
           result = expertise_runner.domains_at_risk
-          result.to_json
+          json_dump(result)
         end
 
         # Expertise for an agent
         get '/api/apollo/expertise/:agent_id' do
           result = expertise_runner.agent_profile(agent_id: params[:agent_id])
-          result.to_json
+          json_dump(result)
         end
 
         # Statistics
         get '/api/apollo/stats' do
-          self.class.stats_payload.to_json
+          json_dump(self.class.stats_payload)
         end
       end
     end

data/lib/legion/extensions/apollo/gaia_integration.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative 'helpers/data_models'
+
 module Legion
   module Extensions
     module Apollo
@@ -22,18 +24,19 @@ module Legion
           end
 
           def publishable?(insight)
-            (insight[:confidence] || 0) > PUBLISH_CONFIDENCE_THRESHOLD &&
-              (insight[:novelty] || 0) > PUBLISH_NOVELTY_THRESHOLD
+            confidence = (insight[:confidence] || 0).to_f
+            novelty = insight[:novelty] ? insight[:novelty].to_f : (1.0 - confidence)
+            confidence > PUBLISH_CONFIDENCE_THRESHOLD && novelty > PUBLISH_NOVELTY_THRESHOLD
           end
 
           def handle_mesh_departure(agent_id:)
-            return nil unless defined?(Legion::Data::Model::ApolloExpertise)
+            return nil unless Helpers::DataModels.apollo_expertise_available?
 
-            sole_expert_domains = Legion::Data::Model::ApolloExpertise
-                                  .where(agent_id: agent_id)
-                                  .all
-                                  .select { |e| sole_expert?(e.domain, agent_id) }
-                                  .map(&:domain)
+            sole_expert_domains = Helpers::DataModels.apollo_expertise
+                                                     .where(agent_id: agent_id)
+                                                     .all
+                                                     .select { |e| sole_expert?(e.domain, agent_id) }
+                                                     .map(&:domain)
 
             return nil if sole_expert_domains.empty?
 
@@ -48,12 +51,12 @@ module Legion
           private
 
           def sole_expert?(domain, agent_id)
-            return false unless defined?(Legion::Data::Model::ApolloExpertise)
+            return false unless Helpers::DataModels.apollo_expertise_available?
 
-            count = Legion::Data::Model::ApolloExpertise
-                    .where(domain: domain)
-                    .exclude(agent_id: agent_id)
-                    .count
+            count = Helpers::DataModels.apollo_expertise
+                                       .where(domain: domain)
+                                       .exclude(agent_id: agent_id)
+                                       .count
             count.zero?
           end
         end

data/lib/legion/extensions/apollo/helpers/capability.rb

@@ -5,20 +5,20 @@ module Legion
     module Apollo
       module Helpers
         module Capability
+          extend Legion::Logging::Helper
+          extend Legion::Settings::Helper
+
           EMBEDDING_MODELS = %w[mxbai-embed-large bge-large snowflake-arctic-embed].freeze
+          PRIVILEGE_MUTEX = Mutex.new
 
           module_function
 
-          def log
-            Legion::Logging
-          end
-
           def can_embed?
             return false unless defined?(Legion::LLM) && Legion::LLM.started?
 
             ollama_embedding_available? || cloud_embedding_configured?
           rescue StandardError => e
-            log.warn("Apollo Capability.can_embed? failed: #{e.message}")
+            handle_exception(e, level: :warn, operation: 'apollo.capability.can_embed')
             false
           end
 
@@ -28,14 +28,14 @@ module Legion
 
             check_db_write_privilege
           rescue StandardError => e
-            log.warn("Apollo Capability.can_write? failed: #{e.message}")
+            handle_exception(e, level: :warn, operation: 'apollo.capability.can_write')
             false
           end
 
           def apollo_write_enabled?
-            Legion::Settings.dig(:data, :apollo_write) == true
+            settings[:data][:apollo_write] == true
           rescue StandardError => e
-            log.warn("Apollo Capability.apollo_write_enabled? failed: #{e.message}")
+            handle_exception(e, level: :warn, operation: 'apollo.capability.apollo_write_enabled')
             false
           end
 
@@ -44,27 +44,29 @@ module Legion
 
             EMBEDDING_MODELS.any? { |m| Legion::LLM::Discovery::Ollama.model_available?(m) }
           rescue StandardError => e
-            log.warn("Apollo Capability.ollama_embedding_available? failed: #{e.message}")
+            handle_exception(e, level: :warn, operation: 'apollo.capability.ollama_embedding_available')
             false
           end
 
           def cloud_embedding_configured?
-            provider = Legion::Settings.dig(:apollo, :embedding, :provider)
-            model = Legion::Settings.dig(:apollo, :embedding, :model)
+            provider = settings[:embedding][:provider]
+            model = settings[:embedding][:model]
             !provider.nil? && !model.nil?
           rescue StandardError => e
-            log.warn("Apollo Capability.cloud_embedding_configured? failed: #{e.message}")
+            handle_exception(e, level: :warn, operation: 'apollo.capability.cloud_embedding_configured')
             false
           end
 
           def check_db_write_privilege
-            return @apollo_write_privilege unless @apollo_write_privilege.nil?
+            PRIVILEGE_MUTEX.synchronize do
+              return @apollo_write_privilege unless @apollo_write_privilege.nil?
 
-            @apollo_write_privilege = Legion::Data.connection
-                                                  .fetch("SELECT has_table_privilege(current_user, 'apollo_entries', 'INSERT') AS can_insert")
-                                                  .first[:can_insert] == true
+              @apollo_write_privilege = Legion::Data.connection
+                                                    .fetch("SELECT has_table_privilege(current_user, 'apollo_entries', 'INSERT') AS can_insert")
+                                                    .first[:can_insert] == true
+            end
           rescue StandardError => e
-            log.warn("Apollo Capability.check_db_write_privilege failed: #{e.message}")
+            handle_exception(e, level: :warn, operation: 'apollo.capability.check_db_write_privilege')
             @apollo_write_privilege = false
           end
 

data/lib/legion/extensions/apollo/helpers/confidence.rb

@@ -5,6 +5,9 @@ module Legion
     module Apollo
       module Helpers
         module Confidence
+          extend Legion::Logging::Helper
+          extend Legion::Settings::Helper
+
           INITIAL_CONFIDENCE = 0.5
           CORROBORATION_BOOST = 0.3
           RETRIEVAL_BOOST = 0.02
@@ -21,16 +24,10 @@ module Legion
 
           module_function
 
-          def log
-            Legion::Logging
-          end
-
           def apollo_setting(*keys, default:)
-            return default unless defined?(Legion::Settings) && !Legion::Settings[:apollo].nil?
-
-            Legion::Settings[:apollo].dig(*keys) || default
+            settings.dig(*keys)
           rescue StandardError => e
-            log.warn("Apollo Confidence.apollo_setting failed: #{e.message}")
+            handle_exception(e, level: :warn, operation: 'apollo.confidence.apollo_setting', keys: keys)
             default
           end
 

data/lib/legion/extensions/apollo/helpers/data_models.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Apollo
+      module Helpers
+        module DataModels
+          class << self
+            def apollo_entry
+              namespaced_apollo_model(:Entry) || legacy_model(:ApolloEntry)
+            end
+
+            def apollo_relation
+              namespaced_apollo_model(:Relation) || legacy_model(:ApolloRelation)
+            end
+
+            def apollo_access_log
+              namespaced_apollo_model(:AccessLog) || legacy_model(:ApolloAccessLog)
+            end
+
+            def apollo_expertise
+              namespaced_apollo_model(:Expertise) || legacy_model(:ApolloExpertise)
+            end
+
+            def apollo_entry_available?
+              !apollo_entry.nil?
+            end
+
+            def apollo_relation_available?
+              !apollo_relation.nil?
+            end
+
+            def apollo_access_log_available?
+              !apollo_access_log.nil?
+            end
+
+            def apollo_expertise_available?
+              !apollo_expertise.nil?
+            end
+
+            private
+
+            def namespaced_apollo_model(name)
+              return nil unless defined?(Legion::Data::Model::Apollo)
+              return nil unless Legion::Data::Model::Apollo.const_defined?(name, false)
+
+              Legion::Data::Model::Apollo.const_get(name, false)
+            end
+
+            def legacy_model(name)
+              return nil unless defined?(Legion::Data::Model)
+              return nil unless Legion::Data::Model.const_defined?(name, false)
+
+              Legion::Data::Model.const_get(name, false)
+            end
+          end
+        end
+      end
+    end
+  end
+end