lex-apollo 0.4.28 → 0.4.44

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

@@ -31,16 +31,10 @@ module Legion
             content = response_content(response)
             return false if content.nil? || content.length < min_content_length
 
-            tool_calls = extract_tool_calls(response, enrichments)
-            research_calls = tool_calls.select { |tc| RESEARCH_TOOLS.include?(tc[:name] || tc['name']) }
-
-            return false if research_calls.empty?
-
-            apollo_results = enrichments['rag_context:apollo_results']
-            return true if apollo_results.nil? || (apollo_results[:count] || 0).zero?
-
-            # Apollo had results — only capture if LLM also did additional research
-            research_calls.any?
+            extract_tool_calls(response, enrichments).any? do |call|
+              name = call.respond_to?(:name) ? call.name : call[:name] || call['name']
+              RESEARCH_TOOLS.include?(name)
+            end
           end
 
           def build_payload(request:, response:, source_channel: nil)
@@ -147,9 +141,11 @@ module Legion
 
           def extract_tool_calls(response, enrichments)
             calls = []
-            calls += Array(response.tool_calls) if response.respond_to?(:tool_calls)
-            calls += Array(enrichments['tool_calls']) if enrichments['tool_calls']
-            calls.uniq { |tc| tc[:name] || tc['name'] }
+            calls.concat(Array(response.tools)) if response.respond_to?(:tools)
+            calls.concat(Array(response.tool_calls)) if response.respond_to?(:tool_calls)
+            calls.concat(Array(enrichments['tool_calls'])) if enrichments['tool_calls']
+            calls.uniq! { |call| call.respond_to?(:name) ? call.name : call[:name] || call['name'] }
+            calls
           end
 
           def derive_tags(query)

data/lib/legion/extensions/apollo/runners/entity_extractor.rb

@@ -8,7 +8,7 @@ module Legion
           DEFAULT_ENTITY_TYPES = %w[person service repository concept].freeze
           DEFAULT_MIN_CONFIDENCE = 0.7
 
-          def extract_entities(text:, entity_types: nil, min_confidence: Helpers::Confidence.apollo_setting(:entity_extractor, :min_confidence, default: DEFAULT_MIN_CONFIDENCE), **) # rubocop:disable Layout/LineLength
+          def extract_entities(text:, entity_types: nil, min_confidence: Legion::Extensions::Apollo.settings[:entity_extractor][:min_confidence], **)
             if text.to_s.strip.empty?
               log.debug('Apollo EntityExtractor.extract_entities skipped reason=empty_text')
               return { success: true, entities: [], source: :empty }

data/lib/legion/extensions/apollo/runners/expertise.rb

@@ -7,11 +7,11 @@ module Legion
     module Apollo
       module Runners
         module Expertise
-          def get_expertise(domain:, min_proficiency: Helpers::Confidence.apollo_setting(:expertise, :initial_proficiency, default: 0.0), **)
+          def get_expertise(domain:, min_proficiency: Legion::Extensions::Apollo.settings[:expertise][:initial_proficiency], **)
             { action: :expertise_query, domain: domain, min_proficiency: min_proficiency }
           end
 
-          def domains_at_risk(min_agents: Helpers::Confidence.apollo_setting(:expertise, :min_agents_at_risk, default: 2), **)
+          def domains_at_risk(min_agents: Legion::Extensions::Apollo.settings[:expertise][:min_agents_at_risk], **)
             { action: :domains_at_risk, min_agents: min_agents }
           end
 
@@ -75,7 +75,7 @@ module Legion
 
           def expertise_proficiency(confidences)
             avg = confidences.sum / confidences.size
-            cap = Helpers::Confidence.apollo_setting(:expertise, :proficiency_cap, default: 1.0)
+            cap = Legion::Extensions::Apollo.settings[:expertise][:proficiency_cap]
             [avg * Math.log2(confidences.size + 1), cap].min
           end
 

data/lib/legion/extensions/apollo/runners/gas.rb

@@ -27,11 +27,11 @@ module Legion
             json_parse(str)
           end
 
-          def relate_confidence_gate = Helpers::Confidence.apollo_setting(:gas, :relate_confidence_gate, default: RELATE_CONFIDENCE_GATE)
-          def synthesis_confidence_cap = Helpers::Confidence.apollo_setting(:gas, :synthesis_confidence_cap, default: SYNTHESIS_CONFIDENCE_CAP)
-          def max_anticipations       = Helpers::Confidence.apollo_setting(:gas, :max_anticipations, default: MAX_ANTICIPATIONS)
-          def similar_entries_limit   = Helpers::Confidence.apollo_setting(:gas, :similar_entries_limit, default: 3)
-          def fallback_confidence     = Helpers::Confidence.apollo_setting(:gas, :fallback_confidence, default: 0.5)
+          def relate_confidence_gate = Legion::Extensions::Apollo.settings[:gas][:relate_confidence_gate]
+          def synthesis_confidence_cap = Legion::Extensions::Apollo.settings[:gas][:synthesis_confidence_cap]
+          def max_anticipations       = Legion::Extensions::Apollo.settings[:gas][:max_anticipations]
+          def similar_entries_limit   = Legion::Extensions::Apollo.settings[:gas][:similar_entries_limit]
+          def fallback_confidence     = Legion::Extensions::Apollo.settings[:gas][:fallback_confidence]
 
           def process(audit_event)
             unless processable?(audit_event)
@@ -139,31 +139,101 @@ module Legion
             []
           end
 
-          # Phase 5: Deposit - atomic write to Apollo
-          def phase_deposit(facts, _entities, _relations, _synthesis, audit_event)
-            unless defined?(Runners::Knowledge)
-              log.debug('GAS phase_deposit skipped reason=knowledge_runner_unavailable')
-              return { deposited: 0 }
+          # Phase 5: Deposit entries, then link successfully stored facts.
+          def phase_deposit(facts, _entities, relations, synthesis, audit_event)
+            counts = { deposited: 0, failed: 0, facts: 0, synthesis: 0 }
+            unless defined?(Legion::Extensions::Apollo::Runners::Knowledge)
+              return counts.merge(failed: facts.size + synthesis.size, relations: 0,
+                                  relations_failed: relations.size, relations_skipped: 0)
             end
 
-            deposited = 0
-            facts.each do |fact|
-              Runners::Knowledge.handle_ingest(
-                content:          fact[:content],
-                content_type:     fact[:content_type].to_s,
-                tags:             %w[gas auto_extracted],
-                source_agent:     'gas_pipeline',
-                source_provider:  audit_event.dig(:routing, :provider)&.to_s,
-                knowledge_domain: 'general',
-                context:          { source_request_id: audit_event[:request_id] }
-              )
-              deposited += 1
+            fact_ids = Array.new(facts.size)
+            source_ids = {}
+            { facts: facts, synthesis: synthesis }.each do |kind, entries|
+              entries.each_with_index do |item, index|
+                context = { source_request_id: audit_event[:request_id] }
+                if kind == :synthesis
+                  context[:source_indices] = Array(item[:source_indices])
+                  context[:source_entry_ids] = context[:source_indices].filter_map do |source_index|
+                    fact_ids[source_index] if source_index.is_a?(Integer) && source_index.between?(0, facts.size - 1)
+                  end.uniq
+                end
+                result = Legion::Extensions::Apollo::Runners::Knowledge.handle_ingest(
+                  content: item[:content], content_type: item[:content_type].to_s,
+                  tags: %w[gas auto_extracted], source_agent: 'gas_pipeline',
+                  source_provider: audit_event.dig(:routing, :provider),
+                  knowledge_domain: 'general', context: context
+                )
+                unless result.is_a?(Hash) && result[:success] == true && result[:entry_id]
+                  counts[:failed] += 1
+                  next
+                end
+
+                counts[:deposited] += 1
+                counts[kind] += 1
+                next unless kind == :facts
+
+                fact_ids[index] = result[:entry_id]
+                ids = (source_ids[item[:content]] ||= [])
+                ids << result[:entry_id] unless ids.include?(result[:entry_id])
+              rescue StandardError => e
+                counts[:failed] += 1
+                handle_exception(e, level: :warn, operation: 'apollo.gas.phase_deposit_entry')
+              end
+            end
+            counts.merge!(gas_deposit_relations(relations: relations, source_ids: source_ids))
+            log.info("GAS phase_deposit deposited=#{counts[:deposited]} failed=#{counts[:failed]} relations=#{counts[:relations]} relations_failed=#{counts[:relations_failed]}") # rubocop:disable Layout/LineLength
+            counts
+          end
+
+          def gas_deposit_relations(relations:, source_ids:)
+            counts = { relations: 0, relations_failed: 0, relations_skipped: 0 }
+            return counts if relations.empty?
+            unless Legion::Extensions::Apollo::Helpers::DataModels.apollo_entry_available? &&
+                   Legion::Extensions::Apollo::Helpers::DataModels.apollo_relation_available?
+              return counts.merge(relations_failed: relations.size)
+            end
+
+            entry_model = Legion::Extensions::Apollo::Helpers::DataModels.apollo_entry
+            relation_model = Legion::Extensions::Apollo::Helpers::DataModels.apollo_relation
+            seen = {}
+            relations.each do |relation|
+              type = relation[:relation_type].to_s
+              weight = relation[:confidence]
+              unless gas_relation_accepted?(type: type, confidence: weight)
+                counts[:relations_skipped] += 1
+                next
+              end
+              ids = source_ids[relation[:from_content]]
+              source = entry_model[ids.first] if ids&.one?
+              target = entry_model[relation[:to_id]] if relation[:to_id]
+              unless source && target
+                counts[:relations_failed] += 1
+                next
+              end
+
+              key = [source.id, target.id, type]
+              if source.id == target.id || source[:access_scope] != target[:access_scope] || seen[key]
+                counts[:relations_skipped] += 1
+                next
+              end
+              seen[key] = true
+              relation_model.create(from_entry_id: source.id, to_entry_id: target.id, relation_type: type,
+                                    weight: weight, source_agent: 'gas_pipeline')
+              counts[:relations] += 1
             rescue StandardError => e
-              handle_exception(e, level: :warn, operation: 'apollo.gas.phase_deposit_fact')
+              counts[:relations_failed] += 1
+              handle_exception(e, level: :warn, operation: 'apollo.gas.phase_deposit_relation')
             end
-            log.info("GAS phase_deposit deposited=#{deposited} facts=#{facts.size}")
-            { deposited: deposited }
+            counts
+          end
+
+          def gas_relation_accepted?(type:, confidence:)
+            Legion::Extensions::Apollo::Helpers::Confidence::RELATION_TYPES.include?(type) &&
+              confidence.is_a?(Numeric) && confidence.real? && confidence.finite? &&
+              confidence.between?(relate_confidence_gate, 1.0)
           end
+          private_class_method :gas_deposit_relations, :gas_relation_accepted?
 
           # Phase 6: Anticipate - pre-cache likely follow-up questions
           def phase_anticipate(facts, _synthesis)