lex-apollo 0.4.23 → 0.4.25

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: af5cbbe35e69f28430c0c4d2862294024e465b79a7fdba279bb50562bc0d81d4
-  data.tar.gz: d2cf12984c06eb60752f7202935649a411377ca141e20d719d2faa2ec4c05b3b
+  metadata.gz: 96a0b3d72ad8895d264315b2da3710c323d31280cf08fe615f8db74c9c762e82
+  data.tar.gz: a6d938a7409cfd0f1b5f3a0dc6c7f1f3c0399dc93a8b7ba8ffcfff0c82536bc3
 SHA512:
-  metadata.gz: a2bf398b3f6df58ec0e84f810f7ba4e48e68991c88f95ae8e5614ba4510ae7ab9be3994dc757f34138073797cb2af99c795d532f4e24dc9fb2f09ffa0b18d13f
-  data.tar.gz: fad944b5457ef0574bb53b1d88251d5d4dce1a70b3cbe8ffadb25b3938877a0170cd36adbf41705d066d84f7036043914efa6b7473db5999daf24badde8a7f5d
+  metadata.gz: efd4519deb1935da01026f3149460fafd110be233f7cdaf522c1980c4cab70a2debcb4ca4ba8a7e3b5b8be0b409d94fdf566fdba6cc8bcdcc1a3ebef879ef6fe
+  data.tar.gz: b0b446a0af1010dde65247cff125c17d086ebba9cf9bd0269575fc7d94fed6eab06a2d836ee6419d742b4fe150aa7b055deefb11e6160b30bde83f79b5c63d71

data/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## [0.4.25] - 2026-05-08
+
+### Fixed
+- Entity watchdog now remembers processed task-log text during the process lifetime so unchanged logs do not trigger repeated structured LLM extraction on every watchdog interval.
+
+## [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

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

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'digest'
 require 'legion/extensions/actors/every'
 require_relative '../runners/knowledge'
 require_relative '../runners/entity_extractor'
@@ -40,6 +41,8 @@ module Legion
 
             ingested = 0
             texts.each do |text|
+              next if task_log_text_processed?(text)
+
               result = extract_entities(
                 text:           text,
                 entity_types:   entity_types,
@@ -47,6 +50,7 @@ module Legion
               )
               next unless result[:success]
 
+              mark_task_log_text_processed(text) unless result[:source] == :unavailable
               result[:entities].each do |entity|
                 next if entity_exists_in_apollo?(entity)
 
@@ -124,6 +128,28 @@ module Legion
           def dedup_similarity_threshold
             settings[:entity_watchdog][:dedup_threshold].to_f
           end
+
+          def task_log_text_processed?(text)
+            processed_task_log_hashes.key?(task_log_text_hash(text))
+          end
+
+          def mark_task_log_text_processed(text)
+            hashes = processed_task_log_hashes
+            hashes[task_log_text_hash(text)] = true
+            hashes.shift while hashes.size > processed_task_log_hash_limit
+          end
+
+          def processed_task_log_hashes
+            @processed_task_log_hashes ||= {}
+          end
+
+          def processed_task_log_hash_limit
+            [settings[:entity_watchdog][:log_limit].to_i * 4, 100].max
+          end
+
+          def task_log_text_hash(text)
+            Digest::SHA256.hexdigest(text.to_s)
+          end
         end
       end
     end

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

@@ -24,8 +24,9 @@ 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:)

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

@@ -9,6 +9,7 @@ module Legion
           extend Legion::Settings::Helper
 
           EMBEDDING_MODELS = %w[mxbai-embed-large bge-large snowflake-arctic-embed].freeze
+          PRIVILEGE_MUTEX = Mutex.new
 
           module_function
 
@@ -57,11 +58,13 @@ module Legion
           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
             handle_exception(e, level: :warn, operation: 'apollo.capability.check_db_write_privilege')
             @apollo_write_privilege = false

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

@@ -212,7 +212,7 @@ module Legion
             { from_content: fact[:content], to_id: entry[:id], relation_type: 'similar_to', confidence: fallback_confidence }
           end
 
-          def llm_classify_relation(fact, entry)
+          def llm_classify_relation(fact, entry) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
             prompt = <<~PROMPT
               Classify the relationship between these two knowledge entries.
               Valid types: #{RELATION_TYPES.join(', ')}
@@ -245,9 +245,13 @@ module Legion
               phase:   'gas_relate'
             )
 
-            content = result.respond_to?(:message) ? result.message[:content] : result.to_s
-            parsed = json_load(content)
-            rels = parsed.is_a?(Hash) ? (parsed[:relations] || parsed['relations'] || []) : []
+            rels = if result.is_a?(Hash) && result[:data].is_a?(Hash)
+                     result[:data][:relations] || result.dig(:data, 'relations') || []
+                   else
+                     content = result.respond_to?(:message) ? result.message[:content] : result.to_s
+                     parsed = json_load(content)
+                     parsed.is_a?(Hash) ? (parsed[:relations] || parsed['relations'] || []) : []
+                   end
             best = rels.max_by { |r| r[:confidence] || r['confidence'] || 0 }
 
             return fallback_relation(fact, entry) unless best
@@ -302,9 +306,13 @@ module Legion
               phase:   'gas_synthesize'
             )
 
-            content = result.respond_to?(:message) ? result.message[:content] : result.to_s
-            parsed = json_load(content)
-            items = parsed.is_a?(Hash) ? (parsed[:synthesis] || parsed['synthesis'] || []) : []
+            items = if result.is_a?(Hash) && result[:data].is_a?(Hash)
+                      result[:data][:synthesis] || result.dig(:data, 'synthesis') || []
+                    else
+                      content = result.respond_to?(:message) ? result.message[:content] : result.to_s
+                      parsed = json_load(content)
+                      parsed.is_a?(Hash) ? (parsed[:synthesis] || parsed['synthesis'] || []) : []
+                    end
 
             items.map { |item| build_synthesis_entry(item, facts) }
           rescue StandardError => e
@@ -358,9 +366,13 @@ module Legion
               phase:   'gas_anticipate'
             )
 
-            content = result.respond_to?(:message) ? result.message[:content] : result.to_s
-            parsed = json_load(content)
-            questions = parsed.is_a?(Hash) ? (parsed[:questions] || parsed['questions'] || []) : []
+            questions = if result.is_a?(Hash) && result[:data].is_a?(Hash)
+                          result[:data][:questions] || result.dig(:data, 'questions') || []
+                        else
+                          content = result.respond_to?(:message) ? result.message[:content] : result.to_s
+                          parsed = json_load(content)
+                          parsed.is_a?(Hash) ? (parsed[:questions] || parsed['questions'] || []) : []
+                        end
             questions = questions.first(max_anticipations)
 
             questions.map do |q|
@@ -426,9 +438,13 @@ module Legion
               phase:   'gas_comprehend'
             )
 
-            content = result.respond_to?(:message) ? result.message[:content] : result.to_s
-            parsed = json_load(content)
-            facts_array = parsed.is_a?(Hash) ? (parsed[:facts] || parsed['facts'] || []) : Array(parsed)
+            facts_array = if result.is_a?(Hash) && result[:data].is_a?(Hash)
+                            result[:data][:facts] || result.dig(:data, 'facts') || []
+                          else
+                            content = result.respond_to?(:message) ? result.message[:content] : result.to_s
+                            parsed = json_load(content)
+                            parsed.is_a?(Hash) ? (parsed[:facts] || parsed['facts'] || []) : Array(parsed)
+                          end
             facts_array.map do |f|
               {
                 content:      f[:content] || f['content'],

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

@@ -133,7 +133,7 @@ module Legion
             { success: false, error: e.message }
           end
 
-          def handle_query(query:, limit: Helpers::GraphQuery.default_query_limit, min_confidence: Helpers::GraphQuery.default_query_min_confidence, status: UNSET, tags: nil, domain: nil, agent_id: 'unknown', **) # rubocop:disable Layout/LineLength
+          def handle_query(query:, limit: Helpers::GraphQuery.default_query_limit, min_confidence: Helpers::GraphQuery.default_query_min_confidence, status: UNSET, tags: nil, domain: nil, agent_id: 'unknown', **) # rubocop:disable Layout/LineLength, Metrics/CyclomaticComplexity
             return { success: false, error: 'apollo_data_not_available' } unless Helpers::DataModels.apollo_entry_available?
 
             entry_model = Helpers::DataModels.apollo_entry
@@ -147,6 +147,12 @@ module Legion
             end
 
             embedding = embed_text(query)
+            if embedding.nil?
+              log.warn('Apollo Knowledge.handle_query embedding unavailable; falling back to browse query')
+              return list_entries_chronologically(query: query, limit: limit, status: requested_status,
+                                                  status_defaulted: status_defaulted, tags: tags, domain: domain)
+            end
+
             sql = Helpers::GraphQuery.build_semantic_search_sql(
               limit: limit, min_confidence: min_confidence,
               statuses: Array(requested_status).map(&:to_s), tags: tags, domain: domain
@@ -255,6 +261,11 @@ module Legion
             return { success: true, entries: [], count: 0 } if query.nil? || query.to_s.strip.empty?
 
             embedding = embed_text(query)
+            if embedding.nil?
+              log.warn('Apollo Knowledge.retrieve_relevant embedding unavailable; returning empty result')
+              return { success: true, entries: [], count: 0, degraded: :no_embedding }
+            end
+
             sql = Helpers::GraphQuery.build_semantic_search_sql(
               limit: limit, min_confidence: min_confidence,
               statuses: %w[confirmed candidate], tags: tags, domain: domain
@@ -354,12 +365,6 @@ module Legion
               return { success: false, error: 'content is required' }
             end
 
-            if content_type.nil?
-              log.warn('[apollo][handle_ingest] early-return: content_type is required ' \
-                       "content_length=#{content.to_s.length}")
-              return { success: false, error: 'content_type is required' }
-            end
-
             return nil if Helpers::DataModels.apollo_entry_available?
 
             log.warn('[apollo][handle_ingest] early-return: apollo_data_not_available ' \
@@ -378,16 +383,16 @@ module Legion
             log.debug("Apollo Knowledge.embed_text text_length=#{text.length}")
             result = Legion::LLM::Call::Embeddings.generate(text: text)
             vector = result.is_a?(Hash) ? result[:vector] : result
-            if vector.is_a?(Array) && vector.any?
+            if vector.is_a?(Array) && vector.any? && vector.any? { |v| v != 0.0 }
               log.debug("Apollo Knowledge.embed_text vector_dimensions=#{vector.length}")
               vector
             else
-              log.warn('Apollo Knowledge.embed_text returned no vector; using zero-vector fallback')
-              Array.new(1024, 0.0)
+              log.warn('Apollo Knowledge.embed_text returned no usable vector; skipping embedding')
+              nil
             end
           rescue StandardError => e
             handle_exception(e, level: :warn, operation: 'apollo.knowledge.embed_text')
-            Array.new(1024, 0.0)
+            nil
           end
 
           def normalize_text_input(value)
@@ -460,7 +465,7 @@ module Legion
               submitted_by:     metadata[:submitted_by],
               submitted_from:   metadata[:submitted_from],
               content_hash:     content_hash,
-              embedding:        Sequel.lit("'[#{embedding.join(',')}]'::vector")
+              embedding:        embedding ? Sequel.lit("'[#{embedding.join(',')}]'::vector") : nil
             )
             log.info("Apollo Knowledge.handle_ingest created entry_id=#{new_entry.id} status=candidate domain=#{metadata[:domain]} source_agent=#{metadata[:source_agent]}") # rubocop:disable Layout/LineLength
             new_entry.id
@@ -584,6 +589,8 @@ module Legion
           end
 
           def find_corroboration(embedding, content_type_sym, source_agent, source_channel = nil)
+            return [false, nil] unless embedding
+
             scan_limit = Helpers::Confidence.apollo_setting(:corroboration, :scan_limit, default: 50)
             log.debug("Apollo Knowledge.find_corroboration content_type=#{content_type_sym} source_agent=#{source_agent} source_channel=#{source_channel || 'nil'} scan_limit=#{scan_limit}") # rubocop:disable Layout/LineLength
             existing = Helpers::DataModels.apollo_entry
@@ -611,13 +618,6 @@ module Legion
                 confidence: Helpers::Confidence.apply_corroboration_boost(confidence: entry.confidence, weight: weight),
                 updated_at: Time.now
               )
-              Helpers::DataModels.apollo_relation.create(
-                from_entry_id: entry.id,
-                to_entry_id:   entry.id,
-                relation_type: 'similar_to',
-                source_agent:  source_agent,
-                weight:        sim
-              )
               log.info("Apollo Knowledge.find_corroboration matched entry_id=#{entry.id} source_agent=#{source_agent} similarity=#{sim}")
               return [true, entry.id]
             end

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

@@ -43,7 +43,8 @@ module Legion
             )
 
             min_age_filter = Sequel.lit(
-              "COALESCE(updated_at, created_at) < NOW() - INTERVAL '? hours'", min_age_hours
+              "COALESCE(updated_at, created_at) < NOW() - (? * INTERVAL '1 hour')",
+              min_age_hours
             )
 
             decayed = conn[:apollo_entries]
@@ -71,8 +72,8 @@ module Legion
               return { success: false, error: 'apollo_data_not_available' }
             end
 
-            candidates = Helpers::DataModels.apollo_entry.where(status: 'candidate').exclude(embedding: nil).all
-            confirmed = Helpers::DataModels.apollo_entry.where(status: 'confirmed').exclude(embedding: nil).all
+            candidates = Helpers::DataModels.apollo_entry.where(status: 'candidate').exclude(embedding: nil).limit(100).all
+            confirmed = Helpers::DataModels.apollo_entry.where(status: 'confirmed').exclude(embedding: nil).limit(500).all
             log.debug("Apollo Maintenance.check_corroboration candidates=#{candidates.size} confirmed=#{confirmed.size}")
 
             promoted = 0

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

@@ -3,7 +3,7 @@
 module Legion
   module Extensions
     module Apollo
-      VERSION = '0.4.23'
+      VERSION = '0.4.25'
     end
   end
 end

data/spec/legion/extensions/apollo/actors/entity_watchdog_spec.rb

@@ -67,6 +67,13 @@ RSpec.describe Legion::Extensions::Apollo::Actor::EntityWatchdog do
       expect(actor).to have_received(:publish_entity_ingest).once
     end
 
+    it 'does not extract entities from the same task log text twice' do
+      actor.scan_and_ingest
+      actor.scan_and_ingest
+
+      expect(actor).to have_received(:extract_entities).once
+    end
+
     context 'when entity already exists in Apollo (high similarity)' do
       let(:existing_match) do
         { success: true, entries: [{ id: 42, content: 'lex-synapse', distance: 0.02 }], count: 1 }

data/spec/legion/extensions/apollo/runners/knowledge_spec.rb

@@ -18,7 +18,7 @@ RSpec.describe Legion::Extensions::Apollo::Runners::Knowledge do
   before do
     embeddings_mod = Module.new do
       def self.generate(*, **)
-        { vector: Array.new(1024, 0.0), model: 'test', provider: :ollama, dimensions: 1024, tokens: 0 }
+        { vector: Array.new(1024, 0.1), model: 'test', provider: :ollama, dimensions: 1024, tokens: 0 }
       end
     end
     stub_const('Legion::LLM::Call::Embeddings', embeddings_mod)
@@ -159,7 +159,7 @@ RSpec.describe Legion::Extensions::Apollo::Runners::Knowledge do
         stub_const('Legion::Data::Model::ApolloExpertise', mock_expertise_class)
         stub_const('Legion::Data::Model::ApolloAccessLog', mock_access_log_class)
         allow(Legion::LLM::Call::Embeddings).to receive(:generate)
-          .and_return({ vector: Array.new(1024, 0.0), model: 'test', provider: :ollama, dimensions: 1024, tokens: 0 })
+          .and_return({ vector: Array.new(1024, 0.1), model: 'test', provider: :ollama, dimensions: 1024, tokens: 0 })
 
         # Corroboration lookup chain
         allow(mock_entry_class).to receive(:where).and_return(double(exclude: double(limit: empty_dataset)))
@@ -328,7 +328,7 @@ RSpec.describe Legion::Extensions::Apollo::Runners::Knowledge do
       before do
         stub_const('Legion::Data::Model::ApolloEntry', Class.new)
         allow(Legion::LLM::Call::Embeddings).to receive(:generate)
-          .and_return({ vector: Array.new(1024, 0.0), model: 'test', provider: :ollama, dimensions: 1024, tokens: 0 })
+          .and_return({ vector: Array.new(1024, 0.1), model: 'test', provider: :ollama, dimensions: 1024, tokens: 0 })
         allow(Legion::Data::Model::ApolloEntry).to receive(:where)
           .and_raise(Sequel::Error, 'connection lost')
       end
@@ -406,7 +406,7 @@ RSpec.describe Legion::Extensions::Apollo::Runners::Knowledge do
         stub_const('Legion::Data::Model::ApolloEntry', mock_entry_class)
         stub_const('Legion::Data::Model::ApolloAccessLog', mock_access_log_class)
         allow(Legion::LLM::Call::Embeddings).to receive(:generate)
-          .and_return({ vector: Array.new(1024, 0.0), model: 'test', provider: :ollama, dimensions: 1024, tokens: 0 })
+          .and_return({ vector: Array.new(1024, 0.1), model: 'test', provider: :ollama, dimensions: 1024, tokens: 0 })
         allow(mock_entry_class).to receive(:db).and_return(mock_db)
         allow(mock_db).to receive(:fetch).and_return(double(all: sample_entries))
         allow(mock_entry_class).to receive(:where).and_return(double(update: true))
@@ -441,7 +441,7 @@ RSpec.describe Legion::Extensions::Apollo::Runners::Knowledge do
       before do
         stub_const('Legion::Data::Model::ApolloEntry', mock_entry_class)
         allow(Legion::LLM::Call::Embeddings).to receive(:generate)
-          .and_return({ vector: Array.new(1024, 0.0), model: 'test', provider: :ollama, dimensions: 1024, tokens: 0 })
+          .and_return({ vector: Array.new(1024, 0.1), model: 'test', provider: :ollama, dimensions: 1024, tokens: 0 })
         allow(mock_entry_class).to receive(:db).and_return(mock_db)
         allow(mock_db).to receive(:fetch).and_return(double(all: []))
       end
@@ -555,7 +555,7 @@ RSpec.describe Legion::Extensions::Apollo::Runners::Knowledge do
       before do
         stub_const('Legion::Data::Model::ApolloEntry', mock_entry_class)
         allow(Legion::LLM::Call::Embeddings).to receive(:generate)
-          .and_return({ vector: Array.new(1024, 0.0), model: 'test', provider: :ollama, dimensions: 1024, tokens: 0 })
+          .and_return({ vector: Array.new(1024, 0.1), model: 'test', provider: :ollama, dimensions: 1024, tokens: 0 })
         allow(mock_entry_class).to receive(:db).and_return(mock_db)
         allow(mock_db).to receive(:fetch).and_return(double(all: sample_entries))
         allow(mock_entry_class).to receive(:where).and_return(double(update: true))

data/spec/legion/extensions/apollo/runners/maintenance_spec.rb

@@ -107,9 +107,9 @@ RSpec.describe Legion::Extensions::Apollo::Runners::Maintenance do
       before do
         stub_const('Legion::Data::Model::ApolloEntry', mock_entry_class)
         allow(mock_entry_class).to receive(:where).with(status: 'candidate')
-                                                  .and_return(double(exclude: double(all: [])))
+                                                  .and_return(double(exclude: double(limit: double(all: []))))
         allow(mock_entry_class).to receive(:where).with(status: 'confirmed')
-                                                  .and_return(double(exclude: double(all: [])))
+                                                  .and_return(double(exclude: double(limit: double(all: []))))
       end
 
       it 'returns zero promoted and scanned' do
@@ -136,9 +136,9 @@ RSpec.describe Legion::Extensions::Apollo::Runners::Maintenance do
         stub_const('Legion::Data::Model::ApolloEntry', mock_entry_class)
         stub_const('Legion::Data::Model::ApolloRelation', mock_relation_class)
         allow(mock_entry_class).to receive(:where).with(status: 'candidate')
-                                                  .and_return(double(exclude: double(all: [candidate])))
+                                                  .and_return(double(exclude: double(limit: double(all: [candidate]))))
         allow(mock_entry_class).to receive(:where).with(status: 'confirmed')
-                                                  .and_return(double(exclude: double(all: [confirmed_entry])))
+                                                  .and_return(double(exclude: double(limit: double(all: [confirmed_entry]))))
         allow(mock_relation_class).to receive(:create)
       end
 
@@ -174,9 +174,9 @@ RSpec.describe Legion::Extensions::Apollo::Runners::Maintenance do
         stub_const('Legion::Data::Model::ApolloEntry', mock_entry_class)
         stub_const('Legion::Data::Model::ApolloRelation', mock_relation_class)
         allow(mock_entry_class).to receive(:where).with(status: 'candidate')
-                                                  .and_return(double(exclude: double(all: [candidate])))
+                                                  .and_return(double(exclude: double(limit: double(all: [candidate]))))
         allow(mock_entry_class).to receive(:where).with(status: 'confirmed')
-                                                  .and_return(double(exclude: double(all: [confirmed_entry])))
+                                                  .and_return(double(exclude: double(limit: double(all: [confirmed_entry]))))
       end
 
       it 'does not promote even with different providers' do
@@ -198,9 +198,9 @@ RSpec.describe Legion::Extensions::Apollo::Runners::Maintenance do
       before do
         stub_const('Legion::Data::Model::ApolloEntry', mock_entry_class)
         allow(mock_entry_class).to receive(:where).with(status: 'candidate')
-                                                  .and_return(double(exclude: double(all: [candidate])))
+                                                  .and_return(double(exclude: double(limit: double(all: [candidate]))))
         allow(mock_entry_class).to receive(:where).with(status: 'confirmed')
-                                                  .and_return(double(exclude: double(all: [confirmed_entry])))
+                                                  .and_return(double(exclude: double(limit: double(all: [confirmed_entry]))))
       end
 
       it 'does not promote' do

data/spec/legion/extensions/apollo/runners/request_spec.rb

@@ -14,7 +14,7 @@ RSpec.describe Legion::Extensions::Apollo::Runners::Request do
 
     embeddings_mod = Module.new do
       def self.generate(*, **)
-        { vector: Array.new(1024, 0.0), model: 'test', provider: :ollama, dimensions: 1024, tokens: 0 }
+        { vector: Array.new(1024, 0.1), model: 'test', provider: :ollama, dimensions: 1024, tokens: 0 }
       end
     end
     stub_const('Legion::LLM::Call::Embeddings', embeddings_mod)
@@ -40,7 +40,7 @@ RSpec.describe Legion::Extensions::Apollo::Runners::Request do
         stub_const('Legion::Data::Model::ApolloEntry', mock_entry_class)
         stub_const('Legion::Data::Model::ApolloAccessLog', mock_access_log_class)
         allow(Legion::LLM::Call::Embeddings).to receive(:generate)
-          .and_return({ vector: Array.new(1024, 0.0), model: 'test', provider: :ollama, dimensions: 1024, tokens: 0 })
+          .and_return({ vector: Array.new(1024, 0.1), model: 'test', provider: :ollama, dimensions: 1024, tokens: 0 })
         allow(mock_entry_class).to receive(:db).and_return(mock_db)
         allow(mock_db).to receive(:fetch).and_return(double(all: sample_entries))
         allow(mock_entry_class).to receive(:where).and_return(double(update: true))
@@ -104,7 +104,7 @@ RSpec.describe Legion::Extensions::Apollo::Runners::Request do
       before do
         stub_const('Legion::Data::Model::ApolloEntry', mock_entry_class)
         allow(Legion::LLM::Call::Embeddings).to receive(:generate)
-          .and_return({ vector: Array.new(1024, 0.0), model: 'test', provider: :ollama, dimensions: 1024, tokens: 0 })
+          .and_return({ vector: Array.new(1024, 0.1), model: 'test', provider: :ollama, dimensions: 1024, tokens: 0 })
         allow(mock_entry_class).to receive(:db).and_return(mock_db)
         allow(mock_db).to receive(:fetch).and_return(double(all: []))
         allow(mock_entry_class).to receive(:where).and_return(double(update: true))
@@ -143,7 +143,7 @@ RSpec.describe Legion::Extensions::Apollo::Runners::Request do
         stub_const('Legion::Data::Model::ApolloExpertise', mock_expertise_class)
         stub_const('Legion::Data::Model::ApolloAccessLog', mock_access_log_class)
         allow(Legion::LLM::Call::Embeddings).to receive(:generate)
-          .and_return({ vector: Array.new(1024, 0.0), model: 'test', provider: :ollama, dimensions: 1024, tokens: 0 })
+          .and_return({ vector: Array.new(1024, 0.1), model: 'test', provider: :ollama, dimensions: 1024, tokens: 0 })
         allow(mock_entry_class).to receive(:where).and_return(double(exclude: double(limit: double(each: nil), first: nil)))
         allow(mock_entry_class).to receive(:exclude)
           .and_return(double(exclude: double(limit: double(all: []))))

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-apollo
 version: !ruby/object:Gem::Version
-  version: 0.4.23
+  version: 0.4.25
 platform: ruby
 authors:
 - Esity