lex-apollo 0.4.18 → 0.4.19

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 87724ea9011349f5f7c008a360728975567903827b5cdcf9a42e2678ca84b134
-  data.tar.gz: ae10f48baf9522bd7087a20e1886fc26170c1f5e0a0c36a3ccac26c836f11885
+  metadata.gz: 1bf0ca8790d13fc3d262ede810ce50a47146dc37743e8806696de970b8a0385a
+  data.tar.gz: 1f1a9115e1a1bb36423150a7290a82352f07aef7aa41f0b4b7da8e0ff5b76f94
 SHA512:
-  metadata.gz: b21c5413da8dfe9f60d9845a578bcfe8337982d128a5041df214004e144b9913dd34cd2da1514a30ea67e21d52604a11218c362a46f9c990c472ac4ec14a0fa9
-  data.tar.gz: ae07a4aba39ce05f20b6a495310b6a20c1c468e0d627393ab931af76d9cd57da5b52075a33706a8b94fadae01c32b65d818d4f5c1018f9eac08a8ffdc10c7ace
+  metadata.gz: 3d92269898b53825fff831ef253fc44ac9e9a45602da25628f32fc95c1e6a53edfd86add2f02f7131c449cd1b940258d2c8fc4df3b90ca6306affbf8a76d4ccb
+  data.tar.gz: d6c98fc7a7f351dc929e2d2dac4c9d7d119e32328706c9880e19a6bc3edb53448b008d8a8fefd7f7e8b8a201084f4ec78006088954cb7e56ee72cb312f0d5ce6

data/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## [0.4.19] - 2026-04-24
+
+### Fixed
+- `store_knowledge` no longer rejects LLM-provided content_type values — normalizes free-form strings (`"reasoning"`, `"text"`, `"text/plain"`, `":fact"`, `"inference"`) to valid symbols via alias map with `:observation` fallback
+- `GaiaIntegration.publish_insight` now passes `:observation` instead of the domain string as content_type (was sending `"general"` or domain names which failed validation)
+- `llm_detects_conflict?` truncates content to 4000 chars before sending to LLM to prevent context overflow errors (was passing full entry content, hitting 65536-token limit)
+
 ## [0.4.18] - 2026-04-24
 
 ### Fixed

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

@@ -15,7 +15,7 @@ module Legion
             client = Legion::Extensions::Apollo::Client.new(agent_id: agent_id)
             client.store_knowledge(
               content:      insight[:content],
-              content_type: insight[:domain] || 'general',
+              content_type: :observation,
               source_agent: agent_id,
               tags:         Array(insight[:tags])
             )

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

@@ -14,11 +14,16 @@ module Legion
             'general'             => :all
           }.freeze
 
+          CONTENT_TYPE_ALIASES = {
+            reasoning: :concept, analysis: :concept, explanation: :concept,
+            text: :observation, general: :observation, note: :observation, summary: :observation,
+            rule: :procedure, step: :procedure, instruction: :procedure,
+            link: :association, relation: :association, connection: :association,
+            inference: :association, implication: :association
+          }.freeze
+
           def store_knowledge(content:, content_type:, tags: [], source_agent: nil, context: {}, **)
-            content_type = content_type.to_sym
-            unless Helpers::Confidence::CONTENT_TYPES.include?(content_type)
-              raise ArgumentError, "invalid content_type: #{content_type}. Must be one of #{Helpers::Confidence::CONTENT_TYPES}"
-            end
+            content_type = normalize_content_type(content_type)
 
             if defined?(Legion::Data::Model::ApolloEntry)
               return handle_ingest(content: content, content_type: content_type,
@@ -324,8 +329,16 @@ module Legion
             { deleted: 0, redacted: 0, error: e.message }
           end
 
+          CONFLICT_CHECK_MAX_CHARS = 4000
+
           private
 
+          def normalize_content_type(raw)
+            sym = raw.to_s.delete_prefix(':').gsub(%r{[/\s]}, '_').strip.downcase.to_sym
+            sym = CONTENT_TYPE_ALIASES.fetch(sym, sym)
+            Helpers::Confidence::CONTENT_TYPES.include?(sym) ? sym : :observation
+          end
+
           def embed_text(text)
             text = normalize_text_input(text)
             result = Legion::LLM::Embeddings.generate(text: text)
@@ -399,10 +412,12 @@ module Legion
           def llm_detects_conflict?(content_a, content_b)
             return false unless defined?(Legion::LLM) && Legion::LLM.respond_to?(:structured)
 
+            a = content_a.to_s[0, CONFLICT_CHECK_MAX_CHARS]
+            b = content_b.to_s[0, CONFLICT_CHECK_MAX_CHARS]
             result = Legion::LLM.structured(
               messages: [
                 { role: 'system', content: 'Do these two statements contradict each other? Return JSON.' },
-                { role: 'user', content: "A: #{content_a}\n\nB: #{content_b}" }
+                { role: 'user', content: "A: #{a}\n\nB: #{b}" }
               ],
               schema:   { type: 'object', properties: { contradicts: { type: 'boolean' } } },
               caller:   { extension: 'lex-apollo', runner: 'knowledge' }

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

@@ -3,7 +3,7 @@
 module Legion
   module Extensions
     module Apollo
-      VERSION = '0.4.18'
+      VERSION = '0.4.19'
     end
   end
 end

data/spec/legion/extensions/apollo/contradiction_spec.rb

@@ -9,6 +9,27 @@ RSpec.describe 'Apollo Contradiction Detection' do
     it 'returns false when LLM unavailable' do
       expect(knowledge.send(:llm_detects_conflict?, 'sky is blue', 'sky is red')).to be false
     end
+
+    context 'when LLM is available' do
+      let(:llm_mod) do
+        Module.new do
+          def self.respond_to?(*) = true
+          def self.structured(**) = { data: { contradicts: true } }
+        end
+      end
+
+      before { stub_const('Legion::LLM', llm_mod) }
+
+      it 'truncates content longer than CONFLICT_CHECK_MAX_CHARS' do
+        long_text = 'x' * 10_000
+        allow(llm_mod).to receive(:structured).and_return({ data: { contradicts: false } })
+        knowledge.send(:llm_detects_conflict?, long_text, long_text)
+        expect(llm_mod).to have_received(:structured) do |**kwargs|
+          user_msg = kwargs[:messages].find { |m| m[:role] == 'user' }[:content]
+          expect(user_msg.length).to be < 10_000
+        end
+      end
+    end
   end
 
   describe '#detect_contradictions' do

data/spec/legion/extensions/apollo/gaia_integration_spec.rb

@@ -44,6 +44,20 @@ RSpec.describe Legion::Extensions::Apollo::GaiaIntegration do
       )
       expect(result).to eq({ success: true })
     end
+
+    it 'passes :observation as content_type regardless of domain' do
+      client_double = instance_double(Legion::Extensions::Apollo::Client)
+      allow(Legion::Extensions::Apollo::Client).to receive(:new).and_return(client_double)
+      allow(client_double).to receive(:store_knowledge).and_return({ success: true })
+
+      described_class.publish_insight(
+        { confidence: 0.9, novelty: 0.5, content: 'insight', domain: 'clinical' },
+        agent_id: 'test-agent'
+      )
+      expect(client_double).to have_received(:store_knowledge).with(
+        hash_including(content_type: :observation)
+      )
+    end
   end
 
   describe 'entity watchdog phase handler' do

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

@@ -45,10 +45,41 @@ RSpec.describe Legion::Extensions::Apollo::Runners::Knowledge do
       expect(result[:source_agent]).to eq('worker-1')
     end
 
-    it 'rejects invalid content_type' do
-      expect do
-        runner.store_knowledge(content: 'test', content_type: :invalid)
-      end.to raise_error(ArgumentError, /content_type/)
+    it 'falls back to :observation for unrecognized content_type' do
+      result = runner.store_knowledge(content: 'test', content_type: 'invalid_type')
+      expect(result[:content_type]).to eq(:observation)
+    end
+
+    it 'normalizes LLM-provided content_type "reasoning" to :concept' do
+      result = runner.store_knowledge(content: 'test', content_type: 'reasoning')
+      expect(result[:content_type]).to eq(:concept)
+    end
+
+    it 'normalizes "text" to :observation' do
+      result = runner.store_knowledge(content: 'test', content_type: 'text')
+      expect(result[:content_type]).to eq(:observation)
+    end
+
+    it 'normalizes "text/plain" to :observation' do
+      result = runner.store_knowledge(content: 'test', content_type: 'text/plain')
+      expect(result[:content_type]).to eq(:observation)
+    end
+
+    it 'strips leading colon from ":fact"' do
+      result = runner.store_knowledge(content: 'test', content_type: ':fact')
+      expect(result[:content_type]).to eq(:fact)
+    end
+
+    it 'normalizes "inference" to :association' do
+      result = runner.store_knowledge(content: 'test', content_type: 'inference')
+      expect(result[:content_type]).to eq(:association)
+    end
+
+    it 'accepts all valid CONTENT_TYPES unchanged' do
+      %i[fact concept procedure association observation].each do |ct|
+        result = runner.store_knowledge(content: 'test', content_type: ct)
+        expect(result[:content_type]).to eq(ct)
+      end
     end
   end
 

metadata

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