lex-apollo 0.4.5 → 0.4.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 692cd508a98259d83ceaf2c6b752c7c87ddeb219145291bd568fa76430e41577
-  data.tar.gz: b02962423b3dff2950af8b51b0cf5035a8db72f6c2ef80c4f1e54f9f0989e25c
+  metadata.gz: 4ed5f6ac36b031c41850cae2f4e4c6768666c4151c730b7557f7d5f21ac24df7
+  data.tar.gz: 870ffad7838f068a01aa2b03af51ba2ae7df1cfe30debda9a8d3275705ef775a
 SHA512:
-  metadata.gz: 7c4989d252540ae09177a73f389a1f4d1a09c51aee09acdf88bdfbb9ffb3e5d7c6522e8cf0953117518011f199f97f1e76dacb6d88aa2f10a48ecfe1da064497
-  data.tar.gz: a806f1485d4f3ef587f2fbd015180c027934ac87b080c4e0264ccb12a478708d89d0aa313ac3c9b2f20ed3c64ec779e2468ec7b457967c7cb6c1ce780324a884
+  metadata.gz: '0583ae3da3f19c3e852929e97947bf49b94e89d37f918d65fcc2507719049ac641ab6867c1e2b7eee899c923c1cb52ec75670c3cab345b159506d34a01099463'
+  data.tar.gz: 4f77f0e210baa01f3e77b06808ddfe06456d4f10358b8add5e4d602b8669be9b8223e6b69c30f2b56b2d18f20e5d0eabde504b05a8426812236d9a5918631bc4

data/CHANGELOG.md

@@ -1,5 +1,27 @@
 # Changelog
 
+## [0.4.7] - 2026-03-25
+
+### Added
+- Knowledge capture writeback system: `Helpers::Writeback` evaluates LLM responses for Apollo ingest with echo chamber prevention
+- `Helpers::TagNormalizer` for mechanical tag normalization (aliases, special chars, max 5)
+- `Helpers::Capability` for detecting embed/write capabilities per node
+- Writeback transport layer: `Messages::Writeback`, `Queues::WritebackStore`, `Queues::WritebackVectorize`
+- Writeback subscription actors: `Actor::WritebackStore` (pre-embedded), `Actor::WritebackVectorize` (needs embedding)
+- Content hash dedup in `Runners::Knowledge#handle_ingest` — collision boosts confidence instead of inserting
+- Identity tracking: `submitted_by`, `submitted_from`, `content_hash` fields on knowledge entries
+
+## [0.4.6] - 2026-03-25
+
+### Added
+- Apollo-specific embedding provider/model settings: `apollo.embedding.provider` and `apollo.embedding.model` override LLM defaults
+- `embedding_opts` helper reads Apollo settings and passes `provider:`/`model:` to `Legion::LLM.embed`
+- Local-first embedding: `detect_local_model` checks Ollama for pulled 1024-dim models (`mxbai-embed-large`, `bge-large`, `snowflake-arctic-embed`) before falling back to cloud provider
+
+### Changed
+- `DEFAULT_DIMENSION` changed from 1536 to 1024 for cross-provider compatibility (Bedrock Titan v2, OpenAI with dimensions:, Ollama models)
+- `Helpers::Embedding.generate` now passes provider/model from Apollo settings, falling back to LLM defaults when not configured
+
 ## [0.4.5] - 2026-03-25
 
 ### Added

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/actors/subscription' if defined?(Legion::Extensions::Actors::Subscription)
+
+module Legion
+  module Extensions
+    module Apollo
+      module Actor
+        class WritebackStore < Legion::Extensions::Actors::Subscription
+          def runner_class    = 'Legion::Extensions::Apollo::Runners::Knowledge'
+          def runner_function = 'handle_ingest'
+          def check_subtask?  = false
+          def generate_task?  = false
+
+          def enabled?
+            defined?(Legion::Extensions::Apollo::Runners::Knowledge) &&
+              defined?(Legion::Transport) &&
+              Helpers::Capability.apollo_write_enabled?
+          rescue StandardError
+            false
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/actors/subscription' if defined?(Legion::Extensions::Actors::Subscription)
+
+module Legion
+  module Extensions
+    module Apollo
+      module Actor
+        class WritebackVectorize < Legion::Extensions::Actors::Subscription
+          def runner_class    = self.class
+          def runner_function = 'handle_vectorize'
+          def check_subtask?  = false
+          def generate_task?  = false
+
+          def handle_vectorize(payload)
+            payload = symbolize(payload)
+            embedding = Helpers::Embedding.generate(text: payload[:content])
+            enriched = payload.merge(embedding: embedding)
+
+            if Helpers::Capability.can_write?
+              Runners::Knowledge.handle_ingest(**enriched)
+            else
+              Transport::Messages::Writeback.new(
+                **enriched, has_embedding: true
+              ).publish
+            end
+
+            { success: true, action: :vectorized }
+          rescue StandardError => e
+            { success: false, error: e.message }
+          end
+
+          def enabled?
+            defined?(Legion::Transport) && Helpers::Capability.can_embed?
+          rescue StandardError
+            false
+          end
+
+          private
+
+          def symbolize(hash)
+            hash.transform_keys(&:to_sym)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Apollo
+      module Helpers
+        module Capability
+          EMBEDDING_MODELS = %w[mxbai-embed-large bge-large snowflake-arctic-embed].freeze
+
+          module_function
+
+          def can_embed?
+            return false unless defined?(Legion::LLM) && Legion::LLM.started?
+
+            ollama_embedding_available? || cloud_embedding_configured?
+          rescue StandardError
+            false
+          end
+
+          def can_write?
+            return false unless apollo_write_enabled?
+            return false unless defined?(Legion::Data) && Legion::Data.connected?
+
+            check_db_write_privilege
+          rescue StandardError
+            false
+          end
+
+          def apollo_write_enabled?
+            Legion::Settings.dig(:data, :apollo_write) == true
+          rescue StandardError
+            false
+          end
+
+          def ollama_embedding_available?
+            return false unless defined?(Legion::LLM::Discovery::Ollama)
+
+            EMBEDDING_MODELS.any? { |m| Legion::LLM::Discovery::Ollama.model_available?(m) }
+          rescue StandardError
+            false
+          end
+
+          def cloud_embedding_configured?
+            provider = Legion::Settings.dig(:apollo, :embedding, :provider)
+            model = Legion::Settings.dig(:apollo, :embedding, :model)
+            !provider.nil? && !model.nil?
+          rescue StandardError
+            false
+          end
+
+          def check_db_write_privilege
+            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
+          rescue StandardError
+            @apollo_write_privilege = false
+          end
+
+          def reset!
+            @apollo_write_privilege = nil
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -5,7 +5,9 @@ module Legion
     module Apollo
       module Helpers
         module Embedding
-          DEFAULT_DIMENSION = 1536
+          DEFAULT_DIMENSION = 1024
+
+          LOCAL_EMBEDDING_MODELS = %w[mxbai-embed-large bge-large snowflake-arctic-embed].freeze
 
           module_function
 
@@ -15,8 +17,15 @@ module Legion
               return zero_vector
             end
 
-            result = Legion::LLM.embed(text)
-            vector = result.is_a?(Hash) ? result[:vector] : result
+            local_model = detect_local_model
+            vector = if local_model
+                       ollama_embed(text, local_model)
+                     else
+                       opts = cloud_embedding_opts
+                       result = Legion::LLM.embed(text, **opts)
+                       result.is_a?(Hash) ? result[:vector] : result
+                     end
+
             if vector.is_a?(Array) && vector.any?
               @dimension = vector.size
               vector
@@ -38,6 +47,53 @@ module Legion
             DEFAULT_DIMENSION
           end
 
+          def ollama_embed(text, model)
+            require 'faraday'
+            base_url = ollama_base_url
+            Legion::Logging.debug("[apollo] embedding via local Ollama: #{model}") if defined?(Legion::Logging)
+            conn = Faraday.new(url: base_url) { |f| f.options.timeout = 10 }
+            response = conn.post('/api/embed', { model: model, input: text }.to_json,
+                                 'Content-Type' => 'application/json')
+            return nil unless response.success?
+
+            parsed = ::JSON.parse(response.body)
+            parsed['embeddings']&.first
+          rescue StandardError => e
+            Legion::Logging.warn("[apollo] local Ollama embed failed: #{e.message}") if defined?(Legion::Logging)
+            nil
+          end
+
+          def ollama_base_url
+            return 'http://localhost:11434' unless defined?(Legion::Settings)
+
+            Legion::Settings[:llm].dig(:providers, :ollama, :base_url) || 'http://localhost:11434'
+          rescue StandardError
+            'http://localhost:11434'
+          end
+
+          def cloud_embedding_opts
+            return {} unless defined?(Legion::Settings) && !Legion::Settings[:apollo].nil?
+
+            embedding = Legion::Settings[:apollo][:embedding] || {}
+            opts = {}
+            opts[:provider] = embedding[:provider].to_sym if embedding[:provider]
+            opts[:model]    = embedding[:model] if embedding[:model]
+            opts
+          rescue StandardError
+            {}
+          end
+
+          def detect_local_model
+            return nil unless defined?(Legion::LLM::Discovery::Ollama)
+
+            LOCAL_EMBEDDING_MODELS.find do |m|
+              Legion::LLM::Discovery::Ollama.model_available?(m) ||
+                Legion::LLM::Discovery::Ollama.model_available?("#{m}:latest")
+            end
+          rescue StandardError
+            nil
+          end
+
           def zero_vector
             Array.new(dimension, 0.0)
           end

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

@@ -32,7 +32,7 @@ module Legion
                 SELECT e.id, e.content, e.content_type, e.confidence, e.tags, e.source_agent,
                        0 AS depth, 1.0::float AS activation
                 FROM apollo_entries e
-                WHERE e.id = $entry_id
+                WHERE e.id = :entry_id
 
                 UNION ALL
 
@@ -72,11 +72,11 @@ module Legion
             <<~SQL
               SELECT e.id, e.content, e.content_type, e.confidence, e.tags, e.source_agent,
                      e.access_count, e.created_at, e.knowledge_domain,
-                     (e.embedding <=> $embedding) AS distance
+                     (e.embedding <=> :embedding) AS distance
               FROM apollo_entries e
               WHERE #{where_clause}
                 AND e.embedding IS NOT NULL
-              ORDER BY e.embedding <=> $embedding
+              ORDER BY e.embedding <=> :embedding
               LIMIT #{limit}
             SQL
           end

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

@@ -10,6 +10,10 @@ module Legion
           module_function
 
           def cosine_similarity(vec_a:, vec_b:, **)
+            vec_a = parse_vector(vec_a)
+            vec_b = parse_vector(vec_b)
+            return 0.0 unless vec_a.is_a?(Array) && vec_b.is_a?(Array)
+
             dot = vec_a.zip(vec_b).sum { |x, y| x * y }
             mag_a = Math.sqrt(vec_a.sum { |x| x**2 })
             mag_b = Math.sqrt(vec_b.sum { |x| x**2 })
@@ -18,6 +22,15 @@ module Legion
             dot / (mag_a * mag_b)
           end
 
+          def parse_vector(vec)
+            return vec if vec.is_a?(Array)
+            return nil unless vec.is_a?(String)
+
+            ::JSON.parse(vec)
+          rescue StandardError
+            nil
+          end
+
           def above_corroboration_threshold?(similarity:, **)
             similarity >= Confidence::CORROBORATION_SIMILARITY_THRESHOLD
           end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Apollo
+      module Helpers
+        module TagNormalizer
+          ALIASES = {
+            'c#' => 'csharp', '.net' => 'dotnet', 'c++' => 'cplusplus',
+            'node.js' => 'nodejs', 'vue.js' => 'vuejs', 'react.js' => 'reactjs'
+          }.freeze
+
+          module_function
+
+          def normalize(raw)
+            tag = raw.to_s.strip.downcase
+            tag = ALIASES[tag] if ALIASES.key?(tag)
+            tag = tag.gsub(/[^a-z0-9\- ]/, '')
+                     .gsub(/\s+/, '-')
+                     .gsub(/-+/, '-')
+                     .sub(/^-/, '')
+                     .sub(/-$/, '')
+            tag.empty? ? nil : tag
+          end
+
+          def normalize_all(tags, max: 5)
+            Array(tags)
+              .filter_map { |t| normalize(t) }
+              .uniq
+              .first(max)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+require 'digest'
+require 'socket'
+
+module Legion
+  module Extensions
+    module Apollo
+      module Helpers
+        module Writeback
+          RESEARCH_TOOLS = %w[read_file search_files search_content run_command].freeze
+          MAX_CONTENT_LENGTH = 4000
+          MIN_CONTENT_LENGTH = 50
+
+          module_function
+
+          def evaluate_and_route(request:, response:, enrichments: {})
+            return unless writeback_enabled?
+            return unless should_capture?(request, response, enrichments)
+
+            payload = build_payload(request: request, response: response)
+            route_payload(payload)
+          rescue StandardError => e
+            Legion::Logging.warn("apollo writeback failed: #{e.message}") if defined?(Legion::Logging)
+          end
+
+          def should_capture?(_request, response, enrichments)
+            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?
+          end
+
+          def build_payload(request:, response:, source_channel: nil)
+            content = response_content(response)
+            caller_identity = extract_identity(request)
+            user_query = extract_user_query(request)
+            tags = derive_tags(user_query)
+
+            {
+              content:          content[0...MAX_CONTENT_LENGTH],
+              content_type:     'observation',
+              tags:             Helpers::TagNormalizer.normalize_all(tags),
+              source_agent:     response.respond_to?(:model) ? response.model : 'unknown',
+              source_channel:   "#{source_channel || 'pipeline'}_synthesis",
+              submitted_by:     caller_identity,
+              submitted_from:   Socket.gethostname,
+              knowledge_domain: nil,
+              content_hash:     content_hash(content)
+            }
+          end
+
+          def route_payload(payload)
+            can_embed = Helpers::Capability.can_embed?
+            can_write = Helpers::Capability.can_write?
+
+            if can_embed
+              embedding = Helpers::Embedding.generate(text: payload[:content])
+              payload[:embedding] = embedding
+            end
+
+            if can_write && can_embed
+              write_directly(payload)
+            else
+              publish_to_transport(payload, has_embedding: can_embed)
+            end
+          end
+
+          def write_directly(payload)
+            Runners::Knowledge.handle_ingest(**payload)
+          rescue StandardError => e
+            Legion::Logging.warn("apollo direct write failed, falling back to transport: #{e.message}") if defined?(Legion::Logging)
+            publish_to_transport(payload, has_embedding: !payload[:embedding].nil?)
+          end
+
+          def publish_to_transport(payload, has_embedding: false)
+            return unless defined?(Legion::Transport)
+
+            Transport::Messages::Writeback.new(
+              **payload, has_embedding: has_embedding
+            ).publish
+          rescue StandardError => e
+            Legion::Logging.warn("apollo writeback publish failed: #{e.message}") if defined?(Legion::Logging)
+          end
+
+          def writeback_enabled?
+            Legion::Settings.dig(:apollo, :writeback, :enabled) != false
+          rescue StandardError
+            true
+          end
+
+          def min_content_length
+            Legion::Settings.dig(:apollo, :writeback, :min_content_length) || MIN_CONTENT_LENGTH
+          rescue StandardError
+            MIN_CONTENT_LENGTH
+          end
+
+          def content_hash(content)
+            normalized = content.to_s.strip.downcase.gsub(/\s+/, ' ')
+            Digest::MD5.hexdigest(normalized)
+          end
+
+          def response_content(response)
+            msg = response.respond_to?(:message) ? response.message : nil
+            return nil unless msg.is_a?(Hash)
+
+            msg[:content] || msg['content']
+          end
+
+          def extract_identity(request)
+            return 'unknown' unless request.respond_to?(:caller) && request.caller.is_a?(Hash)
+
+            request.caller.dig(:requested_by, :identity) || 'unknown'
+          rescue StandardError
+            'unknown'
+          end
+
+          def extract_user_query(request)
+            return '' unless request.respond_to?(:messages)
+
+            user_msgs = Array(request.messages).select { |m| m[:role] == 'user' || m['role'] == 'user' }
+            (user_msgs.last || {})[:content] || ''
+          rescue StandardError
+            ''
+          end
+
+          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'] }
+          end
+
+          def derive_tags(query)
+            stop_words = %w[a an the is are was were be been being have has had do does did will would shall
+                            should may might can could of in to for on with at by from as into about between
+                            how what when where why who which this that these those it its and or but not]
+            words = query.to_s.downcase.gsub(/[^a-z0-9\s]/, '').split
+            words.reject { |w| stop_words.include?(w) || w.length < 3 }
+                 .uniq
+                 .first(5)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -59,12 +59,25 @@ module Legion
             }
           end
 
-          def handle_ingest(content:, content_type:, tags: [], source_agent: 'unknown', source_provider: nil, source_channel: nil, knowledge_domain: nil, context: {}, **) # rubocop:disable Metrics/ParameterLists, Layout/LineLength
+          def handle_ingest(content:, content_type:, tags: [], source_agent: 'unknown', source_provider: nil, source_channel: nil, knowledge_domain: nil, submitted_by: nil, submitted_from: nil, content_hash: nil, context: {}, **) # rubocop:disable Metrics/ParameterLists, Layout/LineLength
             return { success: false, error: 'apollo_data_not_available' } unless defined?(Legion::Data::Model::ApolloEntry)
 
+            # Content hash dedup
+            hash = content_hash || (defined?(Helpers::Writeback) ? Helpers::Writeback.content_hash(content) : nil)
+            if hash
+              existing = Legion::Data::Model::ApolloEntry
+                         .where(content_hash: hash)
+                         .exclude(status: 'archived')
+                         .first
+              if existing
+                existing.update(confidence: [existing.confidence + Helpers::Confidence.retrieval_boost, 1.0].min)
+                return { success: true, entry_id: existing.id, deduped: true }
+              end
+            end
+
             embedding = Helpers::Embedding.generate(text: content)
             content_type_sym = content_type.to_s
-            tag_array = Array(tags)
+            tag_array = defined?(Helpers::TagNormalizer) ? Helpers::TagNormalizer.normalize_all(tags) : Array(tags)
             domain = knowledge_domain || tag_array.first || 'general'
 
             corroborated, existing_id = find_corroboration(embedding, content_type_sym, source_agent, source_channel)
@@ -81,6 +94,9 @@ module Legion
                 tags:             Sequel.pg_array(tag_array),
                 status:           'candidate',
                 knowledge_domain: domain,
+                submitted_by:     submitted_by,
+                submitted_from:   submitted_from,
+                content_hash:     hash,
                 embedding:        Sequel.lit("'[#{embedding.join(',')}]'::vector")
               )
               existing_id = new_entry.id
@@ -112,6 +128,8 @@ module Legion
             db = Legion::Data::Model::ApolloEntry.db
             entries = db.fetch(sql, embedding: Sequel.lit("'[#{embedding.join(',')}]'::vector")).all
 
+            entries = entries.reject { |e| e[:distance].respond_to?(:nan?) && e[:distance].nan? }
+
             entries.each do |entry|
               Legion::Data::Model::ApolloEntry.where(id: entry[:id]).update(
                 access_count: Sequel.expr(:access_count) + 1,
@@ -130,7 +148,7 @@ module Legion
 
             formatted = entries.map do |entry|
               { id: entry[:id], content: entry[:content], content_type: entry[:content_type],
-                confidence: entry[:confidence], distance: entry[:distance],
+                confidence: entry[:confidence], distance: entry[:distance]&.to_f,
                 tags: entry[:tags], source_agent: entry[:source_agent],
                 knowledge_domain: entry[:knowledge_domain] }
             end
@@ -218,6 +236,7 @@ module Legion
 
             db = Legion::Data::Model::ApolloEntry.db
             entries = db.fetch(sql, embedding: Sequel.lit("'[#{embedding.join(',')}]'::vector")).all
+            entries = entries.reject { |e| e[:distance].respond_to?(:nan?) && e[:distance].nan? }
 
             entries.each do |entry|
               Legion::Data::Model::ApolloEntry.where(id: entry[:id]).update(
@@ -228,7 +247,7 @@ module Legion
 
             formatted = entries.map do |entry|
               { id: entry[:id], content: entry[:content], content_type: entry[:content_type],
-                confidence: entry[:confidence], distance: entry[:distance],
+                confidence: entry[:confidence], distance: entry[:distance]&.to_f,
                 tags: entry[:tags], source_agent: entry[:source_agent],
                 knowledge_domain: entry[:knowledge_domain] }
             end
@@ -313,7 +332,7 @@ module Legion
 
             db = Legion::Data::Model::ApolloEntry.db
             similar = db.fetch(
-              "SELECT id, content, embedding FROM apollo_entries WHERE id != $entry_id AND embedding IS NOT NULL ORDER BY embedding <=> $embedding LIMIT #{sim_limit}", # rubocop:disable Layout/LineLength
+              "SELECT id, content, embedding FROM apollo_entries WHERE id != :entry_id AND embedding IS NOT NULL ORDER BY embedding <=> :embedding LIMIT #{sim_limit}", # rubocop:disable Layout/LineLength
               entry_id:  entry_id,
               embedding: Sequel.lit("'[#{embedding.join(',')}]'::vector")
             ).all

data/lib/legion/extensions/apollo/transport/messages/writeback.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'legion/transport/message' if defined?(Legion::Transport)
+
+module Legion
+  module Extensions
+    module Apollo
+      module Transport
+        module Messages
+          class Writeback < Legion::Transport::Message
+            def exchange
+              Exchanges::Apollo
+            end
+
+            def routing_key
+              @options[:has_embedding] ? 'apollo.writeback.store' : 'apollo.writeback.vectorize'
+            end
+
+            def type
+              'apollo_writeback'
+            end
+
+            def message
+              {
+                content:          @options[:content],
+                content_type:     @options[:content_type],
+                tags:             @options[:tags],
+                source_agent:     @options[:source_agent],
+                source_channel:   @options[:source_channel],
+                submitted_by:     @options[:submitted_by],
+                submitted_from:   @options[:submitted_from],
+                embedding:        @options[:embedding],
+                knowledge_domain: @options[:knowledge_domain],
+                context:          @options[:context] || {}
+              }.compact
+            end
+
+            def validate
+              raise TypeError, 'content is required' unless @options[:content].is_a?(String)
+
+              @valid = true
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/apollo/transport/queues/writeback_store.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'legion/transport/queue' if defined?(Legion::Transport)
+
+module Legion
+  module Extensions
+    module Apollo
+      module Transport
+        module Queues
+          class WritebackStore < Legion::Transport::Queue
+            def queue_name
+              'apollo.writeback.store'
+            end
+
+            def queue_options
+              { manual_ack: true, durable: true, arguments: { 'x-dead-letter-exchange': 'apollo.dlx' } }
+            end
+          end
+        end
+      end
+    end
+  end
+end